File rexml-test.patch of Package ruby2.5.36162
diff --git a/lib/rexml.rb b/lib/rexml.rb
new file mode 100644
index 0000000000..eee246e436
--- /dev/null
+++ b/lib/rexml.rb
@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rexml/document"
diff --git a/lib/rexml/attlistdecl.rb b/lib/rexml/attlistdecl.rb
index dc1d2add0b..44a91d66d6 100644
--- a/lib/rexml/attlistdecl.rb
+++ b/lib/rexml/attlistdecl.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: false
#vim:ts=2 sw=2 noexpandtab:
-require 'rexml/child'
-require 'rexml/source'
+require_relative 'child'
+require_relative 'source'
module REXML
# This class needs:
diff --git a/lib/rexml/attribute.rb b/lib/rexml/attribute.rb
index ca5984e178..fe48745ccf 100644
--- a/lib/rexml/attribute.rb
+++ b/lib/rexml/attribute.rb
@@ -1,6 +1,6 @@
-# frozen_string_literal: false
-require "rexml/namespace"
-require 'rexml/text'
+# frozen_string_literal: true
+require_relative "namespace"
+require_relative 'text'
module REXML
# Defines an Element Attribute; IE, a attribute=value pair, as in:
@@ -13,9 +13,6 @@ class Attribute
# The element to which this attribute belongs
attr_reader :element
- # The normalized value of this attribute. That is, the attribute with
- # entities intact.
- attr_writer :normalized
PATTERN = /\s*(#{NAME_STR})\s*=\s*(["'])(.*?)\2/um
NEEDS_A_SECOND_CHECK = /(<|&((#{Entity::NAME});|(#0*((?:\d+)|(?:x[a-fA-F0-9]+)));)?)/um
@@ -67,15 +64,11 @@ def initialize( first, second=nil, parent=nil )
# e.add_attribute( "nsa:a", "aval" )
# e.add_attribute( "b", "bval" )
# e.attributes.get_attribute( "a" ).prefix # -> "nsa"
- # e.attributes.get_attribute( "b" ).prefix # -> "elns"
+ # e.attributes.get_attribute( "b" ).prefix # -> ""
# a = Attribute.new( "x", "y" )
# a.prefix # -> ""
def prefix
- pf = super
- if pf == ""
- pf = @element.prefix if @element
- end
- pf
+ super
end
# Returns the namespace URL, if defined, or nil otherwise
@@ -86,9 +79,26 @@ def prefix
# e.add_attribute("nsx:a", "c")
# e.attribute("ns:a").namespace # => "http://url"
# e.attribute("nsx:a").namespace # => nil
+ #
+ # This method always returns "" for no namespace attribute. Because
+ # the default namespace doesn't apply to attribute names.
+ #
+ # From https://www.w3.org/TR/xml-names/#uniqAttrs
+ #
+ # > the default namespace does not apply to attribute names
+ #
+ # e = REXML::Element.new("el")
+ # e.add_namespace("", "http://example.com/")
+ # e.namespace # => "http://example.com/"
+ # e.add_attribute("a", "b")
+ # e.attribute("a").namespace # => ""
def namespace arg=nil
arg = prefix if arg.nil?
- @element.namespace arg
+ if arg == ""
+ ""
+ else
+ @element.namespace(arg)
+ end
end
# Returns true if other is an Attribute and has the same name and value,
@@ -109,10 +119,13 @@ def hash
# b = Attribute.new( "ns:x", "y" )
# b.to_string # -> "ns:x='y'"
def to_string
+ value = to_s
if @element and @element.context and @element.context[:attribute_quote] == :quote
- %Q^#@expanded_name="#{to_s().gsub(/"/, '"')}"^
+ value = value.gsub('"', '"') if value.include?('"')
+ %Q^#@expanded_name="#{value}"^
else
- "#@expanded_name='#{to_s().gsub(/'/, ''')}'"
+ value = value.gsub("'", ''') if value.include?("'")
+ "#@expanded_name='#{value}'"
end
end
@@ -128,7 +141,6 @@ def to_s
return @normalized if @normalized
@normalized = Text::normalize( @unnormalized, doctype )
- @unnormalized = nil
@normalized
end
@@ -136,9 +148,16 @@ def to_s
# have been expanded to their values
def value
return @unnormalized if @unnormalized
- @unnormalized = Text::unnormalize( @normalized, doctype )
- @normalized = nil
- @unnormalized
+
+ @unnormalized = Text::unnormalize(@normalized, doctype,
+ entity_expansion_text_limit: @element&.document&.entity_expansion_text_limit)
+ end
+
+ # The normalized value of this attribute. That is, the attribute with
+ # entities intact.
+ def normalized=(new_normalized)
+ @normalized = new_normalized
+ @unnormalized = nil
end
# Returns a copy of this attribute
@@ -177,7 +196,7 @@ def node_type
end
def inspect
- rv = ""
+ rv = +""
write( rv )
rv
end
diff --git a/lib/rexml/cdata.rb b/lib/rexml/cdata.rb
index 2238446dc4..997f5a08db 100644
--- a/lib/rexml/cdata.rb
+++ b/lib/rexml/cdata.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require "rexml/text"
+require_relative "text"
module REXML
class CData < Text
diff --git a/lib/rexml/child.rb b/lib/rexml/child.rb
index d23451e71e..cc6e9a4719 100644
--- a/lib/rexml/child.rb
+++ b/lib/rexml/child.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require "rexml/node"
+require_relative "node"
module REXML
##
diff --git a/lib/rexml/comment.rb b/lib/rexml/comment.rb
index 822fe0d586..52c58b46f6 100644
--- a/lib/rexml/comment.rb
+++ b/lib/rexml/comment.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require "rexml/child"
+require_relative "child"
module REXML
##
diff --git a/lib/rexml/doctype.rb b/lib/rexml/doctype.rb
index cb9bf57406..f35904845e 100644
--- a/lib/rexml/doctype.rb
+++ b/lib/rexml/doctype.rb
@@ -1,20 +1,25 @@
# frozen_string_literal: false
-require "rexml/parent"
-require "rexml/parseexception"
-require "rexml/namespace"
-require 'rexml/entity'
-require 'rexml/attlistdecl'
-require 'rexml/xmltokens'
+require_relative "parent"
+require_relative "parseexception"
+require_relative "namespace"
+require_relative 'entity'
+require_relative 'attlistdecl'
+require_relative 'xmltokens'
module REXML
class ReferenceWriter
def initialize(id_type,
public_id_literal,
- system_literal)
+ system_literal,
+ context=nil)
@id_type = id_type
@public_id_literal = public_id_literal
@system_literal = system_literal
- @default_quote = "\""
+ if context and context[:prologue_quote] == :apostrophe
+ @default_quote = "'"
+ else
+ @default_quote = "\""
+ end
end
def write(output)
@@ -150,7 +155,8 @@ def write( output, indent=0, transitive=false, ie_hack=false )
if @external_id
reference_writer = ReferenceWriter.new(@external_id,
@long_name,
- @uri)
+ @uri,
+ context)
reference_writer.write(output)
end
unless @children.empty?
@@ -165,7 +171,11 @@ def write( output, indent=0, transitive=false, ie_hack=false )
end
def context
- @parent.context
+ if @parent
+ @parent.context
+ else
+ nil
+ end
end
def entity( name )
@@ -187,7 +197,7 @@ def public
when "SYSTEM"
nil
when "PUBLIC"
- strip_quotes(@long_name)
+ @long_name
end
end
@@ -197,9 +207,9 @@ def public
def system
case @external_id
when "SYSTEM"
- strip_quotes(@long_name)
+ @long_name
when "PUBLIC"
- @uri.kind_of?(String) ? strip_quotes(@uri) : nil
+ @uri.kind_of?(String) ? @uri : nil
end
end
@@ -221,15 +231,6 @@ def notation(name)
notation_decl.name == name
}
end
-
- private
-
- # Method contributed by Henrik Martensson
- def strip_quotes(quoted_string)
- quoted_string =~ /^[\'\"].*[\'\"]$/ ?
- quoted_string[1, quoted_string.length-2] :
- quoted_string
- end
end
# We don't really handle any of these since we're not a validating
@@ -287,8 +288,10 @@ def initialize name, middle, pub, sys
end
def to_s
+ context = nil
+ context = parent.context if parent
notation = "<!NOTATION #{@name}"
- reference_writer = ReferenceWriter.new(@middle, @public, @system)
+ reference_writer = ReferenceWriter.new(@middle, @public, @system, context)
reference_writer.write(notation)
notation << ">"
notation
diff --git a/lib/rexml/document.rb b/lib/rexml/document.rb
index 806bc499cd..d1747dd42f 100644
--- a/lib/rexml/document.rb
+++ b/lib/rexml/document.rb
@@ -1,40 +1,98 @@
# frozen_string_literal: false
-require "rexml/security"
-require "rexml/element"
-require "rexml/xmldecl"
-require "rexml/source"
-require "rexml/comment"
-require "rexml/doctype"
-require "rexml/instruction"
-require "rexml/rexml"
-require "rexml/parseexception"
-require "rexml/output"
-require "rexml/parsers/baseparser"
-require "rexml/parsers/streamparser"
-require "rexml/parsers/treeparser"
+require_relative "security"
+require_relative "element"
+require_relative "xmldecl"
+require_relative "source"
+require_relative "comment"
+require_relative "doctype"
+require_relative "instruction"
+require_relative "rexml"
+require_relative "parseexception"
+require_relative "output"
+require_relative "parsers/baseparser"
+require_relative "parsers/streamparser"
+require_relative "parsers/treeparser"
module REXML
- # Represents a full XML document, including PIs, a doctype, etc. A
- # Document has a single child that can be accessed by root().
- # Note that if you want to have an XML declaration written for a document
- # you create, you must add one; REXML documents do not write a default
- # declaration for you. See |DECLARATION| and |write|.
+ # Represents an XML document.
+ #
+ # A document may have:
+ #
+ # - A single child that may be accessed via method #root.
+ # - An XML declaration.
+ # - A document type.
+ # - Processing instructions.
+ #
+ # == In a Hurry?
+ #
+ # If you're somewhat familiar with XML
+ # and have a particular task in mind,
+ # you may want to see the
+ # {tasks pages}[../doc/rexml/tasks/tocs/master_toc_rdoc.html],
+ # and in particular, the
+ # {tasks page for documents}[../doc/rexml/tasks/tocs/document_toc_rdoc.html].
+ #
class Document < Element
- # A convenient default XML declaration. If you want an XML declaration,
- # the easiest way to add one is mydoc << Document::DECLARATION
- # +DEPRECATED+
- # Use: mydoc << XMLDecl.default
+ # A convenient default XML declaration. Use:
+ #
+ # mydoc << XMLDecl.default
+ #
DECLARATION = XMLDecl.default
- # Constructor
- # @param source if supplied, must be a Document, String, or IO.
- # Documents have their context and Element attributes cloned.
- # Strings are expected to be valid XML documents. IOs are expected
- # to be sources of valid XML documents.
- # @param context if supplied, contains the context of the document;
- # this should be a Hash.
+ # :call-seq:
+ # new(string = nil, context = {}) -> new_document
+ # new(io_stream = nil, context = {}) -> new_document
+ # new(document = nil, context = {}) -> new_document
+ #
+ # Returns a new \REXML::Document object.
+ #
+ # When no arguments are given,
+ # returns an empty document:
+ #
+ # d = REXML::Document.new
+ # d.to_s # => ""
+ #
+ # When argument +string+ is given, it must be a string
+ # containing a valid XML document:
+ #
+ # xml_string = '<root><foo>Foo</foo><bar>Bar</bar></root>'
+ # d = REXML::Document.new(xml_string)
+ # d.to_s # => "<root><foo>Foo</foo><bar>Bar</bar></root>"
+ #
+ # When argument +io_stream+ is given, it must be an \IO object
+ # that is opened for reading, and when read must return a valid XML document:
+ #
+ # File.write('t.xml', xml_string)
+ # d = File.open('t.xml', 'r') do |io|
+ # REXML::Document.new(io)
+ # end
+ # d.to_s # => "<root><foo>Foo</foo><bar>Bar</bar></root>"
+ #
+ # When argument +document+ is given, it must be an existing
+ # document object, whose context and attributes (but not children)
+ # are cloned into the new document:
+ #
+ # d = REXML::Document.new(xml_string)
+ # d.children # => [<root> ... </>]
+ # d.context = {raw: :all, compress_whitespace: :all}
+ # d.add_attributes({'bar' => 0, 'baz' => 1})
+ # d1 = REXML::Document.new(d)
+ # d1.children # => []
+ # d1.context # => {:raw=>:all, :compress_whitespace=>:all}
+ # d1.attributes # => {"bar"=>bar='0', "baz"=>baz='1'}
+ #
+ # When argument +context+ is given, it must be a hash
+ # containing context entries for the document;
+ # see {Element Context}[../doc/rexml/context_rdoc.html]:
+ #
+ # context = {raw: :all, compress_whitespace: :all}
+ # d = REXML::Document.new(xml_string, context)
+ # d.context # => {:raw=>:all, :compress_whitespace=>:all}
+ #
def initialize( source = nil, context = {} )
@entity_expansion_count = 0
+ @entity_expansion_limit = Security.entity_expansion_limit
+ @entity_expansion_text_limit = Security.entity_expansion_text_limit
super()
@context = context
return if source.nil?
@@ -46,26 +104,71 @@ def initialize( source = nil, context = {} )
end
end
+ # :call-seq:
+ # node_type -> :document
+ #
+ # Returns the symbol +:document+.
+ #
def node_type
:document
end
- # Should be obvious
+ # :call-seq:
+ # clone -> new_document
+ #
+ # Returns the new document resulting from executing
+ # <tt>Document.new(self)</tt>. See Document.new.
+ #
def clone
Document.new self
end
- # According to the XML spec, a root node has no expanded name
+ # :call-seq:
+ # expanded_name -> empty_string
+ #
+ # Returns an empty string.
+ #
def expanded_name
''
#d = doc_type
#d ? d.name : "UNDEFINED"
end
-
alias :name :expanded_name
- # We override this, because XMLDecls and DocTypes must go at the start
- # of the document
+ # :call-seq:
+ # add(xml_decl) -> self
+ # add(doc_type) -> self
+ # add(object) -> self
+ #
+ # Adds an object to the document; returns +self+.
+ #
+ # When argument +xml_decl+ is given,
+ # it must be an REXML::XMLDecl object,
+ # which becomes the XML declaration for the document,
+ # replacing the previous XML declaration if any:
+ #
+ # d = REXML::Document.new
+ # d.xml_decl.to_s # => ""
+ # d.add(REXML::XMLDecl.new('2.0'))
+ # d.xml_decl.to_s # => "<?xml version='2.0'?>"
+ #
+ # When argument +doc_type+ is given,
+ # it must be an REXML::DocType object,
+ # which becomes the document type for the document,
+ # replacing the previous document type, if any:
+ #
+ # d = REXML::Document.new
+ # d.doctype.to_s # => ""
+ # d.add(REXML::DocType.new('foo'))
+ # d.doctype.to_s # => "<!DOCTYPE foo>"
+ #
+ # When argument +object+ (not an REXML::XMLDecl or REXML::DocType object)
+ # is given it is added as the last child:
+ #
+ # d = REXML::Document.new
+ # d.add(REXML::Element.new('foo'))
+ # d.to_s # => "<foo/>"
+ #
def add( child )
if child.kind_of? XMLDecl
if @children[0].kind_of? XMLDecl
@@ -99,49 +202,108 @@ def add( child )
end
alias :<< :add
+ # :call-seq:
+ # add_element(name_or_element = nil, attributes = nil) -> new_element
+ #
+ # Adds an element to the document by calling REXML::Element.add_element:
+ #
+ # REXML::Element.add_element(name_or_element, attributes)
def add_element(arg=nil, arg2=nil)
rv = super
raise "attempted adding second root element to document" if @elements.size > 1
rv
end
- # @return the root Element of the document, or nil if this document
- # has no children.
+ # :call-seq:
+ # root -> root_element or nil
+ #
+ # Returns the root element of the document, if it exists, otherwise +nil+:
+ #
+ # d = REXML::Document.new('<root></root>')
+ # d.root # => <root/>
+ # d = REXML::Document.new('')
+ # d.root # => nil
+ #
def root
elements[1]
#self
#@children.find { |item| item.kind_of? Element }
end
- # @return the DocType child of the document, if one exists,
- # and nil otherwise.
+ # :call-seq:
+ # doctype -> doc_type or nil
+ #
+ # Returns the DocType object for the document, if it exists, otherwise +nil+:
+ #
+ # d = REXML::Document.new('<!DOCTYPE document SYSTEM "subjects.dtd">')
+ # d.doctype.class # => REXML::DocType
+ # d = REXML::Document.new('')
+ # d.doctype.class # => nil
+ #
def doctype
@children.find { |item| item.kind_of? DocType }
end
- # @return the XMLDecl of this document; if no XMLDecl has been
- # set, the default declaration is returned.
+ # :call-seq:
+ # xml_decl -> xml_decl
+ #
+ # Returns the XMLDecl object for the document, if it exists,
+ # otherwise the default XMLDecl object:
+ #
+ # d = REXML::Document.new('<?xml version="1.0" encoding="UTF-8"?>')
+ # d.xml_decl.class # => REXML::XMLDecl
+ # d.xml_decl.to_s # => "<?xml version='1.0' encoding='UTF-8'?>"
+ # d = REXML::Document.new('')
+ # d.xml_decl.class # => REXML::XMLDecl
+ # d.xml_decl.to_s # => ""
+ #
def xml_decl
rv = @children[0]
return rv if rv.kind_of? XMLDecl
@children.unshift(XMLDecl.default)[0]
end
- # @return the XMLDecl version of this document as a String.
- # If no XMLDecl has been set, returns the default version.
+ # :call-seq:
+ # version -> version_string
+ #
+ # Returns the XMLDecl version of this document as a string,
+ # if it has been set, otherwise the default version:
+ #
+ # d = REXML::Document.new('<?xml version="2.0" encoding="UTF-8"?>')
+ # d.version # => "2.0"
+ # d = REXML::Document.new('')
+ # d.version # => "1.0"
+ #
def version
xml_decl().version
end
- # @return the XMLDecl encoding of this document as an
- # Encoding object.
- # If no XMLDecl has been set, returns the default encoding.
+ # :call-seq:
+ # encoding -> encoding_string
+ #
+ # Returns the XMLDecl encoding of the document,
+ # if it has been set, otherwise the default encoding:
+ #
+ # d = REXML::Document.new('<?xml version="1.0" encoding="UTF-16"?>')
+ # d.encoding # => "UTF-16"
+ # d = REXML::Document.new('')
+ # d.encoding # => "UTF-8"
+ #
def encoding
xml_decl().encoding
end
- # @return the XMLDecl standalone value of this document as a String.
- # If no XMLDecl has been set, returns the default setting.
+ # :call-seq:
+ # stand_alone?
+ #
+ # Returns the XMLDecl standalone value of the document as a string,
+ # if it has been set, otherwise the default standalone value:
+ #
+ # d = REXML::Document.new('<?xml standalone="yes"?>')
+ # d.stand_alone? # => "yes"
+ # d = REXML::Document.new('')
+ # d.stand_alone? # => nil
+ #
def stand_alone?
xml_decl().stand_alone?
end
@@ -226,7 +388,7 @@ def write(*arguments)
end
formatter = if indent > -1
if transitive
- require "rexml/formatters/transitive"
+ require_relative "formatters/transitive"
REXML::Formatters::Transitive.new( indent, ie_hack )
else
REXML::Formatters::Pretty.new( indent, ie_hack )
@@ -271,10 +433,12 @@ def Document::entity_expansion_text_limit
end
attr_reader :entity_expansion_count
+ attr_writer :entity_expansion_limit
+ attr_accessor :entity_expansion_text_limit
def record_entity_expansion
@entity_expansion_count += 1
- if @entity_expansion_count > Security.entity_expansion_limit
+ if @entity_expansion_count > @entity_expansion_limit
raise "number of entity expansions exceeded, processing aborted."
end
end
diff --git a/lib/rexml/dtd/attlistdecl.rb b/lib/rexml/dtd/attlistdecl.rb
index 32847daadb..1326cb21e4 100644
--- a/lib/rexml/dtd/attlistdecl.rb
+++ b/lib/rexml/dtd/attlistdecl.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require "rexml/child"
+require_relative "../child"
module REXML
module DTD
class AttlistDecl < Child
diff --git a/lib/rexml/dtd/dtd.rb b/lib/rexml/dtd/dtd.rb
index 927d5d847b..8b0f2d753a 100644
--- a/lib/rexml/dtd/dtd.rb
+++ b/lib/rexml/dtd/dtd.rb
@@ -1,10 +1,10 @@
# frozen_string_literal: false
-require "rexml/dtd/elementdecl"
-require "rexml/dtd/entitydecl"
-require "rexml/comment"
-require "rexml/dtd/notationdecl"
-require "rexml/dtd/attlistdecl"
-require "rexml/parent"
+require_relative "elementdecl"
+require_relative "entitydecl"
+require_relative "../comment"
+require_relative "notationdecl"
+require_relative "attlistdecl"
+require_relative "../parent"
module REXML
module DTD
diff --git a/lib/rexml/dtd/elementdecl.rb b/lib/rexml/dtd/elementdecl.rb
index 119fd41a8f..20ed023244 100644
--- a/lib/rexml/dtd/elementdecl.rb
+++ b/lib/rexml/dtd/elementdecl.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require "rexml/child"
+require_relative "../child"
module REXML
module DTD
class ElementDecl < Child
diff --git a/lib/rexml/dtd/entitydecl.rb b/lib/rexml/dtd/entitydecl.rb
index 45707e2f42..312df655ff 100644
--- a/lib/rexml/dtd/entitydecl.rb
+++ b/lib/rexml/dtd/entitydecl.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require "rexml/child"
+require_relative "../child"
module REXML
module DTD
class EntityDecl < Child
diff --git a/lib/rexml/dtd/notationdecl.rb b/lib/rexml/dtd/notationdecl.rb
index cfdf0b9b74..04a9b08aa7 100644
--- a/lib/rexml/dtd/notationdecl.rb
+++ b/lib/rexml/dtd/notationdecl.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require "rexml/child"
+require_relative "../child"
module REXML
module DTD
class NotationDecl < Child
diff --git a/lib/rexml/element.rb b/lib/rexml/element.rb
index ac9b10872c..4e3a60b9a2 100644
--- a/lib/rexml/element.rb
+++ b/lib/rexml/element.rb
@@ -1,23 +1,273 @@
# frozen_string_literal: false
-require "rexml/parent"
-require "rexml/namespace"
-require "rexml/attribute"
-require "rexml/cdata"
-require "rexml/xpath"
-require "rexml/parseexception"
+require_relative "parent"
+require_relative "namespace"
+require_relative "attribute"
+require_relative "cdata"
+require_relative "xpath"
+require_relative "parseexception"
module REXML
- # An implementation note about namespaces:
- # As we parse, when we find namespaces we put them in a hash and assign
- # them a unique ID. We then convert the namespace prefix for the node
- # to the unique ID. This makes namespace lookup much faster for the
- # cost of extra memory use. We save the namespace prefix for the
- # context node and convert it back when we write it.
- @@namespaces = {}
-
- # Represents a tagged XML element. Elements are characterized by
- # having children, attributes, and names, and can themselves be
- # children.
+ # An \REXML::Element object represents an XML element.
+ #
+ # An element:
+ #
+ # - Has a name (string).
+ # - May have a parent (another element).
+ # - Has zero or more children
+ # (other elements, text, CDATA, processing instructions, and comments).
+ # - Has zero or more siblings
+ # (other elements, text, CDATA, processing instructions, and comments).
+ # - Has zero or more named attributes.
+ #
+ # == In a Hurry?
+ #
+ # If you're somewhat familiar with XML
+ # and have a particular task in mind,
+ # you may want to see the
+ # {tasks pages}[../doc/rexml/tasks/tocs/master_toc_rdoc.html],
+ # and in particular, the
+ # {tasks page for elements}[../doc/rexml/tasks/tocs/element_toc_rdoc.html].
+ #
+ # === Name
+ #
+ # An element has a name, which is initially set when the element is created:
+ #
+ # e = REXML::Element.new('foo')
+ # e.name # => "foo"
+ #
+ # The name may be changed:
+ #
+ # e.name = 'bar'
+ # e.name # => "bar"
+ #
+ #
+ # === \Parent
+ #
+ # An element may have a parent.
+ #
+ # Its parent may be assigned explicitly when the element is created:
+ #
+ # e0 = REXML::Element.new('foo')
+ # e1 = REXML::Element.new('bar', e0)
+ # e1.parent # => <foo> ... </>
+ #
+ # Note: the representation of an element always shows the element's name.
+ # If the element has children, the representation indicates that
+ # by including an ellipsis (<tt>...</tt>).
+ #
+ # The parent may be assigned explicitly at any time:
+ #
+ # e2 = REXML::Element.new('baz')
+ # e1.parent = e2
+ # e1.parent # => <baz/>
+ #
+ # When an element is added as a child, its parent is set automatically:
+ #
+ # e1.add_element(e0)
+ # e0.parent # => <bar> ... </>
+ #
+ # For an element that has no parent, method +parent+ returns +nil+.
+ #
+ # === Children
+ #
+ # An element has zero or more children.
+ # The children are an ordered collection
+ # of all objects whose parent is the element itself.
+ #
+ # The children may include any combination of elements, text, comments,
+ # processing instructions, and CDATA.
+ # (This example keeps things clean by controlling whitespace
+ # via a +context+ setting.)
+ #
+ # xml_string = <<-EOT
+ # <root>
+ # <ele_0/>
+ # text 0
+ # <!--comment 0-->
+ # <?target_0 pi_0?>
+ # <![CDATA[cdata 0]]>
+ # <ele_1/>
+ # text 1
+ # <!--comment 1-->
+ # <?target_0 pi_1?>
+ # <![CDATA[cdata 1]]>
+ # </root>
+ # EOT
+ # context = {ignore_whitespace_nodes: :all, compress_whitespace: :all}
+ # d = REXML::Document.new(xml_string, context)
+ # root = d.root
+ # root.children.size # => 10
+ # root.each {|child| p "#{child.class}: #{child}" }
+ #
+ # Output:
+ #
+ # "REXML::Element: <ele_0/>"
+ # "REXML::Text: \n text 0\n "
+ # "REXML::Comment: comment 0"
+ # "REXML::Instruction: <?target_0 pi_0?>"
+ # "REXML::CData: cdata 0"
+ # "REXML::Element: <ele_1/>"
+ # "REXML::Text: \n text 1\n "
+ # "REXML::Comment: comment 1"
+ # "REXML::Instruction: <?target_0 pi_1?>"
+ # "REXML::CData: cdata 1"
+ #
+ # A child may be added using inherited methods
+ # Parent#insert_before or Parent#insert_after:
+ #
+ # xml_string = '<root><a/><c/><d/></root>'
+ # d = REXML::Document.new(xml_string)
+ # root = d.root
+ # c = d.root[1] # => <c/>
+ # root.insert_before(c, REXML::Element.new('b'))
+ # root.to_a # => [<a/>, <b/>, <c/>, <d/>]
+ #
+ # A child may be replaced using Parent#replace_child:
+ #
+ # root.replace_child(c, REXML::Element.new('x'))
+ # root.to_a # => [<a/>, <b/>, <x/>, <d/>]
+ #
+ # A child may be removed using Parent#delete:
+ #
+ # x = root[2] # => <x/>
+ # root.delete(x)
+ # root.to_a # => [<a/>, <b/>, <d/>]
+ #
+ # === Siblings
+ #
+ # An element has zero or more siblings,
+ # which are the other children of the element's parent.
+ #
+ # In the example above, element +ele_1+ is between a CDATA sibling
+ # and a text sibling:
+ #
+ # ele_1 = root[5] # => <ele_1/>
+ # ele_1.previous_sibling # => "cdata 0"
+ # ele_1.next_sibling # => "\n text 1\n "
+ #
+ # === \Attributes
+ #
+ # An element has zero or more named attributes.
+ #
+ # A new element has no attributes:
+ #
+ # e = REXML::Element.new('foo')
+ # e.attributes # => {}
+ #
+ # Attributes may be added:
+ #
+ # e.add_attribute('bar', 'baz')
+ # e.add_attribute('bat', 'bam')
+ # e.attributes.size # => 2
+ # e['bar'] # => "baz"
+ # e['bat'] # => "bam"
+ #
+ # An existing attribute may be modified:
+ #
+ # e.add_attribute('bar', 'bad')
+ # e.attributes.size # => 2
+ # e['bar'] # => "bad"
+ #
+ # An existing attribute may be deleted:
+ #
+ # e.delete_attribute('bar')
+ # e.attributes.size # => 1
+ # e['bar'] # => nil
+ #
+ # == What's Here
+ #
+ # To begin with, what's elsewhere?
+ #
+ # \Class \REXML::Element inherits from its ancestor classes:
+ #
+ # - REXML::Child
+ # - REXML::Parent
+ #
+ # \REXML::Element itself and its ancestors also include modules:
+ #
+ # - {Enumerable}[https://docs.ruby-lang.org/en/master/Enumerable.html]
+ # - REXML::Namespace
+ # - REXML::Node
+ # - REXML::XMLTokens
+ #
+ # === Methods for Creating an \Element
+ #
+ # ::new:: Returns a new empty element.
+ # #clone:: Returns a clone of another element.
+ #
+ # === Methods for Attributes
+ #
+ # {[attribute_name]}[#method-i-5B-5D]:: Returns an attribute value.
+ # #add_attribute:: Adds a new attribute.
+ # #add_attributes:: Adds multiple new attributes.
+ # #attribute:: Returns the attribute value for a given name and optional namespace.
+ # #delete_attribute:: Removes an attribute.
+ #
+ # === Methods for Children
+ #
+ # {[index]}[#method-i-5B-5D]:: Returns the child at the given offset.
+ # #add_element:: Adds an element as the last child.
+ # #delete_element:: Deletes a child element.
+ # #each_element:: Calls the given block with each child element.
+ # #each_element_with_attribute:: Calls the given block with each child element
+ # that meets given criteria,
+ # which can include the attribute name.
+ # #each_element_with_text:: Calls the given block with each child element
+ # that meets given criteria,
+ # which can include text.
+ # #get_elements:: Returns an array of element children that match a given xpath.
+ #
+ # === Methods for \Text Children
+ #
+ # #add_text:: Adds a text node to the element.
+ # #get_text:: Returns a text node that meets specified criteria.
+ # #text:: Returns the text string from the first node that meets specified criteria.
+ # #texts:: Returns an array of the text children of the element.
+ # #text=:: Adds, removes, or replaces the first text child of the element
+ #
+ # === Methods for Other Children
+ #
+ # #cdatas:: Returns an array of the cdata children of the element.
+ # #comments:: Returns an array of the comment children of the element.
+ # #instructions:: Returns an array of the instruction children of the element.
+ #
+ # === Methods for Namespaces
+ #
+ # #add_namespace:: Adds a namespace to the element.
+ # #delete_namespace:: Removes a namespace from the element.
+ # #namespace:: Returns the string namespace URI for the element.
+ # #namespaces:: Returns a hash of all defined namespaces in the element.
+ # #prefixes:: Returns an array of the string prefixes (names)
+ # of all defined namespaces in the element
+ #
+ # === Methods for Querying
+ #
+ # #document:: Returns the document, if any, that the element belongs to.
+ # #root:: Returns the most distant element (not document) ancestor of the element.
+ # #root_node:: Returns the most distant ancestor of the element.
+ # #xpath:: Returns the string xpath to the element
+ # relative to the most distant parent
+ # #has_attributes?:: Returns whether the element has attributes.
+ # #has_elements?:: Returns whether the element has elements.
+ # #has_text?:: Returns whether the element has text.
+ # #next_element:: Returns the next sibling that is an element.
+ # #previous_element:: Returns the previous sibling that is an element.
+ # #raw:: Returns whether raw mode is set for the element.
+ # #whitespace:: Returns whether whitespace is respected for the element.
+ # #ignore_whitespace_nodes:: Returns whether whitespace nodes
+ # are to be ignored for the element.
+ # #node_type:: Returns symbol <tt>:element</tt>.
+ #
+ # === One More Method
+ #
+ # #inspect:: Returns a string representation of the element.
+ #
+ # === Accessors
+ #
+ # #elements:: Returns the REXML::Elements object for the element.
+ # #attributes:: Returns the REXML::Attributes object for the element.
+ # #context:: Returns or sets the context hash for the element.
+ #
class Element < Parent
include Namespace
@@ -30,32 +280,42 @@ class Element < Parent
# whitespace handling.
attr_accessor :context
- # Constructor
- # arg::
- # if not supplied, will be set to the default value.
- # If a String, the name of this object will be set to the argument.
- # If an Element, the object will be shallowly cloned; name,
- # attributes, and namespaces will be copied. Children will +not+ be
- # copied.
- # parent::
- # if supplied, must be a Parent, and will be used as
- # the parent of this object.
- # context::
- # If supplied, must be a hash containing context items. Context items
- # include:
- # * <tt>:respect_whitespace</tt> the value of this is :+all+ or an array of
- # strings being the names of the elements to respect
- # whitespace for. Defaults to :+all+.
- # * <tt>:compress_whitespace</tt> the value can be :+all+ or an array of
- # strings being the names of the elements to ignore whitespace on.
- # Overrides :+respect_whitespace+.
- # * <tt>:ignore_whitespace_nodes</tt> the value can be :+all+ or an array
- # of strings being the names of the elements in which to ignore
- # whitespace-only nodes. If this is set, Text nodes which contain only
- # whitespace will not be added to the document tree.
- # * <tt>:raw</tt> can be :+all+, or an array of strings being the names of
- # the elements to process in raw mode. In raw mode, special
- # characters in text is not converted to or from entities.
+ # :call-seq:
+ # Element.new(name = 'UNDEFINED', parent = nil, context = nil) -> new_element
+ # Element.new(element, parent = nil, context = nil) -> new_element
+ #
+ # Returns a new \REXML::Element object.
+ #
+ # When no arguments are given,
+ # returns an element with name <tt>'UNDEFINED'</tt>:
+ #
+ # e = REXML::Element.new # => <UNDEFINED/>
+ # e.class # => REXML::Element
+ # e.name # => "UNDEFINED"
+ #
+ # When only argument +name+ is given,
+ # returns an element of the given name:
+ #
+ # REXML::Element.new('foo') # => <foo/>
+ #
+ # When only argument +element+ is given, it must be an \REXML::Element object;
+ # returns a shallow copy of the given element:
+ #
+ # e0 = REXML::Element.new('foo')
+ # e1 = REXML::Element.new(e0) # => <foo/>
+ #
+ # When argument +parent+ is also given, it must be an REXML::Parent object:
+ #
+ # e = REXML::Element.new('foo', REXML::Parent.new)
+ # e.parent # => #<REXML::Parent @parent=nil, @children=[<foo/>]>
+ #
+ # When argument +context+ is also given, it must be a hash
+ # representing the context for the element;
+ # see {Element Context}[../doc/rexml/context_rdoc.html]:
+ #
+ # e = REXML::Element.new('foo', nil, {raw: :all})
+ # e.context # => {:raw=>:all}
+ #
def initialize( arg = UNDEFINED, parent=nil, context=nil )
super(parent)
@@ -74,6 +334,27 @@ def initialize( arg = UNDEFINED, parent=nil, context=nil )
end
end
+ # :call-seq:
+ # inspect -> string
+ #
+ # Returns a string representation of the element.
+ #
+ # For an element with no attributes and no children, shows the element name:
+ #
+ # REXML::Element.new.inspect # => "<UNDEFINED/>"
+ #
+ # Shows attributes, if any:
+ #
+ # e = REXML::Element.new('foo')
+ # e.add_attributes({'bar' => 0, 'baz' => 1})
+ # e.inspect # => "<foo bar='0' baz='1'/>"
+ #
+ # Shows an ellipsis (<tt>...</tt>), if there are child elements:
+ #
+ # e.add_element(REXML::Element.new('bar'))
+ # e.add_element(REXML::Element.new('baz'))
+ # e.inspect # => "<foo bar='0' baz='1'> ... </>"
+ #
def inspect
rv = "<#@expanded_name"
@@ -89,60 +370,123 @@ def inspect
end
end
-
- # Creates a shallow copy of self.
- # d = Document.new "<a><b/><b/><c><d/></c></a>"
- # new_a = d.root.clone
- # puts new_a # => "<a/>"
+ # :call-seq:
+ # clone -> new_element
+ #
+ # Returns a shallow copy of the element, containing the name and attributes,
+ # but not the parent or children:
+ #
+ # e = REXML::Element.new('foo')
+ # e.add_attributes({'bar' => 0, 'baz' => 1})
+ # e.clone # => <foo bar='0' baz='1'/>
+ #
def clone
self.class.new self
end
- # Evaluates to the root node of the document that this element
- # belongs to. If this element doesn't belong to a document, but does
- # belong to another Element, the parent's root will be returned, until the
- # earliest ancestor is found.
- #
- # Note that this is not the same as the document element.
- # In the following example, <a> is the document element, and the root
- # node is the parent node of the document element. You may ask yourself
- # why the root node is useful: consider the doctype and XML declaration,
- # and any processing instructions before the document element... they
- # are children of the root node, or siblings of the document element.
- # The only time this isn't true is when an Element is created that is
- # not part of any Document. In this case, the ancestor that has no
- # parent acts as the root node.
- # d = Document.new '<a><b><c/></b></a>'
- # a = d[1] ; c = a[1][1]
- # d.root_node == d # TRUE
- # a.root_node # namely, d
- # c.root_node # again, d
+ # :call-seq:
+ # root_node -> document or element
+ #
+ # Returns the most distant ancestor of +self+.
+ #
+ # When the element is part of a document,
+ # returns the root node of the document.
+ # Note that the root node is different from the document element;
+ # in this example +a+ is document element and the root node is its parent:
+ #
+ # d = REXML::Document.new('<a><b><c/></b></a>')
+ # top_element = d.first # => <a> ... </>
+ # child = top_element.first # => <b> ... </>
+ # d.root_node == d # => true
+ # top_element.root_node == d # => true
+ # child.root_node == d # => true
+ #
+ # When the element is not part of a document, but does have ancestor elements,
+ # returns the most distant ancestor element:
+ #
+ # e0 = REXML::Element.new('foo')
+ # e1 = REXML::Element.new('bar')
+ # e1.parent = e0
+ # e2 = REXML::Element.new('baz')
+ # e2.parent = e1
+ # e2.root_node == e0 # => true
+ #
+ # When the element has no ancestor elements,
+ # returns +self+:
+ #
+ # e = REXML::Element.new('foo')
+ # e.root_node == e # => true
+ #
+ # Related: #root, #document.
+ #
def root_node
parent.nil? ? self : parent.root_node
end
+ # :call-seq:
+ # root -> element
+ #
+ # Returns the most distant _element_ (not document) ancestor of the element:
+ #
+ # d = REXML::Document.new('<a><b><c/></b></a>')
+ # top_element = d.first
+ # child = top_element.first
+ # top_element.root == top_element # => true
+ # child.root == top_element # => true
+ #
+ # For a document, returns the topmost element:
+ #
+ # d.root == top_element # => true
+ #
+ # Related: #root_node, #document.
+ #
def root
- return elements[1] if self.kind_of? Document
- return self if parent.kind_of? Document or parent.nil?
- return parent.root
+ target = self
+ while target
+ return target.elements[1] if target.kind_of? Document
+ parent = target.parent
+ return target if parent.kind_of? Document or parent.nil?
+ target = parent
+ end
+ nil
end
- # Evaluates to the document to which this element belongs, or nil if this
- # element doesn't belong to a document.
+ # :call-seq:
+ # document -> document or nil
+ #
+ # If the element is part of a document, returns that document:
+ #
+ # d = REXML::Document.new('<a><b><c/></b></a>')
+ # top_element = d.first
+ # child = top_element.first
+ # top_element.document == d # => true
+ # child.document == d # => true
+ #
+ # If the element is not part of a document, returns +nil+:
+ #
+ # REXML::Element.new.document # => nil
+ #
+ # For a document, returns +self+:
+ #
+ # d.document == d # => true
+ #
+ # Related: #root, #root_node.
+ #
def document
rt = root
rt.parent if rt
end
- # Evaluates to +true+ if whitespace is respected for this element. This
- # is the case if:
- # 1. Neither :+respect_whitespace+ nor :+compress_whitespace+ has any value
- # 2. The context has :+respect_whitespace+ set to :+all+ or
- # an array containing the name of this element, and
- # :+compress_whitespace+ isn't set to :+all+ or an array containing the
- # name of this element.
- # The evaluation is tested against +expanded_name+, and so is namespace
- # sensitive.
+ # :call-seq:
+ # whitespace
+ #
+ # Returns +true+ if whitespace is respected for this element,
+ # +false+ otherwise.
+ #
+ # See {Element Context}[../doc/rexml/context_rdoc.html].
+ #
+ # The evaluation is tested against the element's +expanded_name+,
+ # and so is namespace-sensitive.
def whitespace
@whitespace = nil
if @context
@@ -159,6 +503,13 @@ def whitespace
@whitespace
end
+ # :call-seq:
+ # ignore_whitespace_nodes
+ #
+ # Returns +true+ if whitespace nodes are ignored for the element.
+ #
+ # See {Element Context}[../doc/rexml/context_rdoc.html].
+ #
def ignore_whitespace_nodes
@ignore_whitespace_nodes = false
if @context
@@ -170,9 +521,12 @@ def ignore_whitespace_nodes
end
end
- # Evaluates to +true+ if raw mode is set for this element. This
- # is the case if the context has :+raw+ set to :+all+ or
- # an array containing the name of this element.
+ # :call-seq:
+ # raw
+ #
+ # Returns +true+ if raw mode is set for the element.
+ #
+ # See {Element Context}[../doc/rexml/context_rdoc.html].
#
# The evaluation is tested against +expanded_name+, and so is namespace
# sensitive.
@@ -180,7 +534,7 @@ def raw
@raw = (@context and @context[:raw] and
(@context[:raw] == :all or
@context[:raw].include? expanded_name))
- @raw
+ @raw
end
#once :whitespace, :raw, :ignore_whitespace_nodes
@@ -189,10 +543,25 @@ def raw
# Namespaces #
#################################################
- # Evaluates to an +Array+ containing the prefixes (names) of all defined
- # namespaces at this context node.
- # doc = Document.new("<a xmlns:x='1' xmlns:y='2'><b/><c xmlns:z='3'/></a>")
- # doc.elements['//b'].prefixes # -> ['x', 'y']
+ # :call-seq:
+ # prefixes -> array_of_namespace_prefixes
+ #
+ # Returns an array of the string prefixes (names) of all defined namespaces
+ # in the element and its ancestors:
+ #
+ # xml_string = <<-EOT
+ # <root>
+ # <a xmlns:x='1' xmlns:y='2'>
+ # <b/>
+ # <c xmlns:z='3'/>
+ # </a>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string, {compress_whitespace: :all})
+ # d.elements['//a'].prefixes # => ["x", "y"]
+ # d.elements['//b'].prefixes # => ["x", "y"]
+ # d.elements['//c'].prefixes # => ["x", "y", "z"]
+ #
def prefixes
prefixes = []
prefixes = parent.prefixes if parent
@@ -200,6 +569,25 @@ def prefixes
return prefixes
end
+ # :call-seq:
+ # namespaces -> array_of_namespace_names
+ #
+ # Returns a hash of all defined namespaces
+ # in the element and its ancestors:
+ #
+ # xml_string = <<-EOT
+ # <root>
+ # <a xmlns:x='1' xmlns:y='2'>
+ # <b/>
+ # <c xmlns:z='3'/>
+ # </a>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # d.elements['//a'].namespaces # => {"x"=>"1", "y"=>"2"}
+ # d.elements['//b'].namespaces # => {"x"=>"1", "y"=>"2"}
+ # d.elements['//c'].namespaces # => {"x"=>"1", "y"=>"2", "z"=>"3"}
+ #
def namespaces
namespaces = {}
namespaces = parent.namespaces if parent
@@ -207,19 +595,26 @@ def namespaces
return namespaces
end
- # Evaluates to the URI for a prefix, or the empty string if no such
- # namespace is declared for this element. Evaluates recursively for
- # ancestors. Returns the default namespace, if there is one.
- # prefix::
- # the prefix to search for. If not supplied, returns the default
- # namespace if one exists
- # Returns::
- # the namespace URI as a String, or nil if no such namespace
- # exists. If the namespace is undefined, returns an empty string
- # doc = Document.new("<a xmlns='1' xmlns:y='2'><b/><c xmlns:z='3'/></a>")
- # b = doc.elements['//b']
- # b.namespace # -> '1'
- # b.namespace("y") # -> '2'
+ # :call-seq:
+ # namespace(prefix = nil) -> string_uri or nil
+ #
+ # Returns the string namespace URI for the element,
+ # possibly deriving from one of its ancestors.
+ #
+ # xml_string = <<-EOT
+ # <root>
+ # <a xmlns='1' xmlns:y='2'>
+ # <b/>
+ # <c xmlns:z='3'/>
+ # </a>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # b = d.elements['//b']
+ # b.namespace # => "1"
+ # b.namespace('y') # => "2"
+ # b.namespace('nosuch') # => nil
+ #
def namespace(prefix=nil)
if prefix.nil?
prefix = prefix()
@@ -229,25 +624,34 @@ def namespace(prefix=nil)
else
prefix = "xmlns:#{prefix}" unless prefix[0,5] == 'xmlns'
end
- ns = attributes[ prefix ]
- ns = parent.namespace(prefix) if ns.nil? and parent
+ ns = nil
+ target = self
+ while ns.nil? and target
+ ns = target.attributes[prefix]
+ target = target.parent
+ end
ns = '' if ns.nil? and prefix == 'xmlns'
return ns
end
- # Adds a namespace to this element.
- # prefix::
- # the prefix string, or the namespace URI if +uri+ is not
- # supplied
- # uri::
- # the namespace URI. May be nil, in which +prefix+ is used as
- # the URI
- # Evaluates to: this Element
- # a = Element.new("a")
- # a.add_namespace("xmlns:foo", "bar" )
- # a.add_namespace("foo", "bar") # shorthand for previous line
- # a.add_namespace("twiddle")
- # puts a #-> <a xmlns:foo='bar' xmlns='twiddle'/>
+ # :call-seq:
+ # add_namespace(prefix, uri = nil) -> self
+ #
+ # Adds a namespace to the element; returns +self+.
+ #
+ # With the single argument +prefix+,
+ # adds a namespace using the given +prefix+ and the namespace URI:
+ #
+ # e = REXML::Element.new('foo')
+ # e.add_namespace('bar')
+ # e.namespaces # => {"xmlns"=>"bar"}
+ #
+ # With both arguments +prefix+ and +uri+ given,
+ # adds a namespace using both arguments:
+ #
+ # e.add_namespace('baz', 'bat')
+ # e.namespaces # => {"xmlns"=>"bar", "baz"=>"bat"}
+ #
def add_namespace( prefix, uri=nil )
unless uri
@attributes["xmlns"] = prefix
@@ -258,16 +662,28 @@ def add_namespace( prefix, uri=nil )
self
end
- # Removes a namespace from this node. This only works if the namespace is
- # actually declared in this node. If no argument is passed, deletes the
- # default namespace.
+ # :call-seq:
+ # delete_namespace(namespace = 'xmlns') -> self
+ #
+ # Removes a namespace from the element.
+ #
+ # With no argument, removes the default namespace:
+ #
+ # d = REXML::Document.new "<a xmlns:foo='bar' xmlns='twiddle'/>"
+ # d.to_s # => "<a xmlns:foo='bar' xmlns='twiddle'/>"
+ # d.root.delete_namespace # => <a xmlns:foo='bar'/>
+ # d.to_s # => "<a xmlns:foo='bar'/>"
+ #
+ # With argument +namespace+, removes the specified namespace:
+ #
+ # d.root.delete_namespace('foo')
+ # d.to_s # => "<a/>"
+ #
+ # Does nothing if no such namespace is found:
+ #
+ # d.root.delete_namespace('nosuch')
+ # d.to_s # => "<a/>"
#
- # Evaluates to: this element
- # doc = Document.new "<a xmlns:foo='bar' xmlns='twiddle'/>"
- # doc.root.delete_namespace
- # puts doc # -> <a xmlns:foo='bar'/>
- # doc.root.delete_namespace 'foo'
- # puts doc # -> <a/>
def delete_namespace namespace="xmlns"
namespace = "xmlns:#{namespace}" unless namespace == 'xmlns'
attribute = attributes.get_attribute(namespace)
@@ -279,20 +695,40 @@ def delete_namespace namespace="xmlns"
# Elements #
#################################################
- # Adds a child to this element, optionally setting attributes in
- # the element.
- # element::
- # optional. If Element, the element is added.
- # Otherwise, a new Element is constructed with the argument (see
- # Element.initialize).
- # attrs::
- # If supplied, must be a Hash containing String name,value
- # pairs, which will be used to set the attributes of the new Element.
- # Returns:: the Element that was added
- # el = doc.add_element 'my-tag'
- # el = doc.add_element 'my-tag', {'attr1'=>'val1', 'attr2'=>'val2'}
- # el = Element.new 'my-tag'
- # doc.add_element el
+ # :call-seq:
+ # add_element(name, attributes = nil) -> new_element
+ # add_element(element, attributes = nil) -> element
+ #
+ # Adds a child element, optionally setting attributes
+ # on the added element; returns the added element.
+ #
+ # With string argument +name+, creates a new element with that name
+ # and adds the new element as a child:
+ #
+ # e0 = REXML::Element.new('foo')
+ # e0.add_element('bar')
+ # e0[0] # => <bar/>
+ #
+ #
+ # With argument +name+ and hash argument +attributes+,
+ # sets attributes on the new element:
+ #
+ # e0.add_element('baz', {'bat' => '0', 'bam' => '1'})
+ # e0[1] # => <baz bat='0' bam='1'/>
+ #
+ # With element argument +element+, adds that element as a child:
+ #
+ # e0 = REXML::Element.new('foo')
+ # e1 = REXML::Element.new('bar')
+ # e0.add_element(e1)
+ # e0[0] # => <bar/>
+ #
+ # With argument +element+ and hash argument +attributes+,
+ # sets attributes on the added element:
+ #
+ # e0.add_element(e1, {'bat' => '0', 'bam' => '1'})
+ # e0[1] # => <bar bat='0' bam='1'/>
+ #
def add_element element, attrs=nil
raise "First argument must be either an element name, or an Element object" if element.nil?
el = @elements.add(element)
@@ -302,52 +738,112 @@ def add_element element, attrs=nil
el
end
+ # :call-seq:
+ # delete_element(index) -> removed_element or nil
+ # delete_element(element) -> removed_element or nil
+ # delete_element(xpath) -> removed_element or nil
+ #
# Deletes a child element.
- # element::
- # Must be an +Element+, +String+, or +Integer+. If Element,
- # the element is removed. If String, the element is found (via XPath)
- # and removed. <em>This means that any parent can remove any
- # descendant.<em> If Integer, the Element indexed by that number will be
- # removed.
- # Returns:: the element that was removed.
- # doc.delete_element "/a/b/c[@id='4']"
- # doc.delete_element doc.elements["//k"]
- # doc.delete_element 1
+ #
+ # When 1-based integer argument +index+ is given,
+ # removes and returns the child element at that offset if it exists;
+ # indexing does not include text nodes;
+ # returns +nil+ if the element does not exist:
+ #
+ # d = REXML::Document.new '<a><b/>text<c/></a>'
+ # a = d.root # => <a> ... </>
+ # a.delete_element(1) # => <b/>
+ # a.delete_element(1) # => <c/>
+ # a.delete_element(1) # => nil
+ #
+ # When element argument +element+ is given,
+ # removes and returns that child element if it exists,
+ # otherwise returns +nil+:
+ #
+ # d = REXML::Document.new '<a><b/>text<c/></a>'
+ # a = d.root # => <a> ... </>
+ # c = a[2] # => <c/>
+ # a.delete_element(c) # => <c/>
+ # a.delete_element(c) # => nil
+ #
+ # When xpath argument +xpath+ is given,
+ # removes and returns the element at xpath if it exists,
+ # otherwise returns +nil+:
+ #
+ # d = REXML::Document.new '<a><b/>text<c/></a>'
+ # a = d.root # => <a> ... </>
+ # a.delete_element('//c') # => <c/>
+ # a.delete_element('//c') # => nil
+ #
def delete_element element
@elements.delete element
end
- # Evaluates to +true+ if this element has at least one child Element
- # doc = Document.new "<a><b/><c>Text</c></a>"
- # doc.root.has_elements # -> true
- # doc.elements["/a/b"].has_elements # -> false
- # doc.elements["/a/c"].has_elements # -> false
+ # :call-seq:
+ # has_elements?
+ #
+ # Returns +true+ if the element has one or more element children,
+ # +false+ otherwise:
+ #
+ # d = REXML::Document.new '<a><b/>text<c/></a>'
+ # a = d.root # => <a> ... </>
+ # a.has_elements? # => true
+ # b = a[0] # => <b/>
+ # b.has_elements? # => false
+ #
def has_elements?
!@elements.empty?
end
- # Iterates through the child elements, yielding for each Element that
- # has a particular attribute set.
- # key::
- # the name of the attribute to search for
- # value::
- # the value of the attribute
- # max::
- # (optional) causes this method to return after yielding
- # for this number of matching children
- # name::
- # (optional) if supplied, this is an XPath that filters
- # the children to check.
- #
- # doc = Document.new "<a><b @id='1'/><c @id='2'/><d @id='1'/><e/></a>"
- # # Yields b, c, d
- # doc.root.each_element_with_attribute( 'id' ) {|e| p e}
- # # Yields b, d
- # doc.root.each_element_with_attribute( 'id', '1' ) {|e| p e}
- # # Yields b
- # doc.root.each_element_with_attribute( 'id', '1', 1 ) {|e| p e}
- # # Yields d
- # doc.root.each_element_with_attribute( 'id', '1', 0, 'd' ) {|e| p e}
+ # :call-seq:
+ # each_element_with_attribute(attr_name, value = nil, max = 0, xpath = nil) {|e| ... }
+ #
+ # Calls the given block with each child element that meets given criteria.
+ #
+ # When only string argument +attr_name+ is given,
+ # calls the block with each child element that has that attribute:
+ #
+ # d = REXML::Document.new '<a><b id="1"/><c id="2"/><d id="1"/><e/></a>'
+ # a = d.root
+ # a.each_element_with_attribute('id') {|e| p e }
+ #
+ # Output:
+ #
+ # <b id='1'/>
+ # <c id='2'/>
+ # <d id='1'/>
+ #
+ # With argument +attr_name+ and string argument +value+ given,
+ # calls the block with each child element that has that attribute
+ # with that value:
+ #
+ # a.each_element_with_attribute('id', '1') {|e| p e }
+ #
+ # Output:
+ #
+ # <b id='1'/>
+ # <d id='1'/>
+ #
+ # With arguments +attr_name+, +value+, and integer argument +max+ given,
+ # calls the block with at most +max+ child elements:
+ #
+ # a.each_element_with_attribute('id', '1', 1) {|e| p e }
+ #
+ # Output:
+ #
+ # <b id='1'/>
+ #
+ # With all arguments given, including +xpath+,
+ # calls the block with only those child elements
+ # that meet the first three criteria,
+ # and also match the given +xpath+:
+ #
+ # a.each_element_with_attribute('id', '1', 2, '//d') {|e| p e }
+ #
+ # Output:
+ #
+ # <d id='1'/>
+ #
def each_element_with_attribute( key, value=nil, max=0, name=nil, &block ) # :yields: Element
each_with_something( proc {|child|
if value.nil?
@@ -358,27 +854,53 @@ def each_element_with_attribute( key, value=nil, max=0, name=nil, &block ) # :yi
}, max, name, &block )
end
- # Iterates through the children, yielding for each Element that
- # has a particular text set.
- # text::
- # the text to search for. If nil, or not supplied, will iterate
- # over all +Element+ children that contain at least one +Text+ node.
- # max::
- # (optional) causes this method to return after yielding
- # for this number of matching children
- # name::
- # (optional) if supplied, this is an XPath that filters
- # the children to check.
- #
- # doc = Document.new '<a><b>b</b><c>b</c><d>d</d><e/></a>'
- # # Yields b, c, d
- # doc.each_element_with_text {|e|p e}
- # # Yields b, c
- # doc.each_element_with_text('b'){|e|p e}
- # # Yields b
- # doc.each_element_with_text('b', 1){|e|p e}
- # # Yields d
- # doc.each_element_with_text(nil, 0, 'd'){|e|p e}
+ # :call-seq:
+ # each_element_with_text(text = nil, max = 0, xpath = nil) {|e| ... }
+ #
+ # Calls the given block with each child element that meets given criteria.
+ #
+ # With no arguments, calls the block with each child element that has text:
+ #
+ # d = REXML::Document.new '<a><b>b</b><c>b</c><d>d</d><e/></a>'
+ # a = d.root
+ # a.each_element_with_text {|e| p e }
+ #
+ # Output:
+ #
+ # <b> ... </>
+ # <c> ... </>
+ # <d> ... </>
+ #
+ # With the single string argument +text+,
+ # calls the block with each element that has exactly that text:
+ #
+ # a.each_element_with_text('b') {|e| p e }
+ #
+ # Output:
+ #
+ # <b> ... </>
+ # <c> ... </>
+ #
+ # With argument +text+ and integer argument +max+,
+ # calls the block with at most +max+ elements:
+ #
+ # a.each_element_with_text('b', 1) {|e| p e }
+ #
+ # Output:
+ #
+ # <b> ... </>
+ #
+ # With all arguments given, including +xpath+,
+ # calls the block with only those child elements
+ # that meet the first two criteria,
+ # and also match the given +xpath+:
+ #
+ # a.each_element_with_text('b', 2, '//c') {|e| p e }
+ #
+ # Output:
+ #
+ # <c> ... </>
+ #
def each_element_with_text( text=nil, max=0, name=nil, &block ) # :yields: Element
each_with_something( proc {|child|
if text.nil?
@@ -389,35 +911,71 @@ def each_element_with_text( text=nil, max=0, name=nil, &block ) # :yields: Eleme
}, max, name, &block )
end
- # Synonym for Element.elements.each
+ # :call-seq:
+ # each_element {|e| ... }
+ #
+ # Calls the given block with each child element:
+ #
+ # d = REXML::Document.new '<a><b>b</b><c>b</c><d>d</d><e/></a>'
+ # a = d.root
+ # a.each_element {|e| p e }
+ #
+ # Output:
+ #
+ # <b> ... </>
+ # <c> ... </>
+ # <d> ... </>
+ # <e/>
+ #
def each_element( xpath=nil, &block ) # :yields: Element
@elements.each( xpath, &block )
end
- # Synonym for Element.to_a
- # This is a little slower than calling elements.each directly.
- # xpath:: any XPath by which to search for elements in the tree
- # Returns:: an array of Elements that match the supplied path
+ # :call-seq:
+ # get_elements(xpath)
+ #
+ # Returns an array of the elements that match the given +xpath+:
+ #
+ # xml_string = <<-EOT
+ # <root>
+ # <a level='1'>
+ # <a level='2'/>
+ # </a>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # d.root.get_elements('//a') # => [<a level='1'> ... </>, <a level='2'/>]
+ #
def get_elements( xpath )
@elements.to_a( xpath )
end
- # Returns the next sibling that is an element, or nil if there is
- # no Element sibling after this one
- # doc = Document.new '<a><b/>text<c/></a>'
- # doc.root.elements['b'].next_element #-> <c/>
- # doc.root.elements['c'].next_element #-> nil
+ # :call-seq:
+ # next_element
+ #
+ # Returns the next sibling that is an element if it exists,
+ # +niL+ otherwise:
+ #
+ # d = REXML::Document.new '<a><b/>text<c/></a>'
+ # d.root.elements['b'].next_element #-> <c/>
+ # d.root.elements['c'].next_element #-> nil
+ #
def next_element
element = next_sibling
element = element.next_sibling until element.nil? or element.kind_of? Element
return element
end
- # Returns the previous sibling that is an element, or nil if there is
- # no Element sibling prior to this one
- # doc = Document.new '<a><b/>text<c/></a>'
- # doc.root.elements['c'].previous_element #-> <b/>
- # doc.root.elements['b'].previous_element #-> nil
+ # :call-seq:
+ # previous_element
+ #
+ # Returns the previous sibling that is an element if it exists,
+ # +niL+ otherwise:
+ #
+ # d = REXML::Document.new '<a><b/>text<c/></a>'
+ # d.root.elements['c'].previous_element #-> <b/>
+ # d.root.elements['b'].previous_element #-> nil
+ #
def previous_element
element = previous_sibling
element = element.previous_sibling until element.nil? or element.kind_of? Element
@@ -429,36 +987,69 @@ def previous_element
# Text #
#################################################
- # Evaluates to +true+ if this element has at least one Text child
+ # :call-seq:
+ # has_text? -> true or false
+ #
+ # Returns +true+ if the element has one or more text noded,
+ # +false+ otherwise:
+ #
+ # d = REXML::Document.new '<a><b/>text<c/></a>'
+ # a = d.root
+ # a.has_text? # => true
+ # b = a[0]
+ # b.has_text? # => false
+ #
def has_text?
not text().nil?
end
- # A convenience method which returns the String value of the _first_
- # child text element, if one exists, and +nil+ otherwise.
+ # :call-seq:
+ # text(xpath = nil) -> text_string or nil
+ #
+ # Returns the text string from the first text node child
+ # in a specified element, if it exists, +nil+ otherwise.
+ #
+ # With no argument, returns the text from the first text node in +self+:
+ #
+ # d = REXML::Document.new "<p>some text <b>this is bold!</b> more text</p>"
+ # d.root.text.class # => String
+ # d.root.text # => "some text "
+ #
+ # With argument +xpath+, returns text from the first text node
+ # in the element that matches +xpath+:
+ #
+ # d.root.text(1) # => "this is bold!"
#
- # <em>Note that an element may have multiple Text elements, perhaps
- # separated by other children</em>. Be aware that this method only returns
- # the first Text node.
+ # Note that an element may have multiple text nodes,
+ # possibly separated by other non-text children, as above.
+ # Even so, the returned value is the string text from the first such node.
#
- # This method returns the +value+ of the first text child node, which
- # ignores the +raw+ setting, so always returns normalized text. See
- # the Text::value documentation.
+ # Note also that the text note is retrieved by method get_text,
+ # and so is always normalized text.
#
- # doc = Document.new "<p>some text <b>this is bold!</b> more text</p>"
- # # The element 'p' has two text elements, "some text " and " more text".
- # doc.root.text #-> "some text "
def text( path = nil )
rv = get_text(path)
return rv.value unless rv.nil?
nil
end
- # Returns the first child Text node, if any, or +nil+ otherwise.
- # This method returns the actual +Text+ node, rather than the String content.
- # doc = Document.new "<p>some text <b>this is bold!</b> more text</p>"
- # # The element 'p' has two text elements, "some text " and " more text".
- # doc.root.get_text.value #-> "some text "
+ # :call-seq:
+ # get_text(xpath = nil) -> text_node or nil
+ #
+ # Returns the first text node child in a specified element, if it exists,
+ # +nil+ otherwise.
+ #
+ # With no argument, returns the first text node from +self+:
+ #
+ # d = REXML::Document.new "<p>some text <b>this is bold!</b> more text</p>"
+ # d.root.get_text.class # => REXML::Text
+ # d.root.get_text # => "some text "
+ #
+ # With argument +xpath+, returns the first text node from the element
+ # that matches +xpath+:
+ #
+ # d.root.get_text(1) # => "this is bold!"
+ #
def get_text path = nil
rv = nil
if path
@@ -470,26 +1061,31 @@ def get_text path = nil
return rv
end
- # Sets the first Text child of this object. See text() for a
- # discussion about Text children.
- #
- # If a Text child already exists, the child is replaced by this
- # content. This means that Text content can be deleted by calling
- # this method with a nil argument. In this case, the next Text
- # child becomes the first Text child. In no case is the order of
- # any siblings disturbed.
- # text::
- # If a String, a new Text child is created and added to
- # this Element as the first Text child. If Text, the text is set
- # as the first Child element. If nil, then any existing first Text
- # child is removed.
- # Returns:: this Element.
- # doc = Document.new '<a><b/></a>'
- # doc.root.text = 'Sean' #-> '<a><b/>Sean</a>'
- # doc.root.text = 'Elliott' #-> '<a><b/>Elliott</a>'
- # doc.root.add_element 'c' #-> '<a><b/>Elliott<c/></a>'
- # doc.root.text = 'Russell' #-> '<a><b/>Russell<c/></a>'
- # doc.root.text = nil #-> '<a><b/><c/></a>'
+ # :call-seq:
+ # text = string -> string
+ # text = nil -> nil
+ #
+ # Adds, replaces, or removes the first text node child in the element.
+ #
+ # With string argument +string+,
+ # creates a new \REXML::Text node containing that string,
+ # honoring the current settings for whitespace and row,
+ # then places the node as the first text child in the element;
+ # returns +string+.
+ #
+ # If the element has no text child, the text node is added:
+ #
+ # d = REXML::Document.new '<a><b/></a>'
+ # d.root.text = 'foo' #-> '<a><b/>foo</a>'
+ #
+ # If the element has a text child, it is replaced:
+ #
+ # d.root.text = 'bar' #-> '<a><b/>bar</a>'
+ #
+ # With argument +nil+, removes the first text child:
+ #
+ # d.root.text = nil #-> '<a><b/><c/></a>'
+ #
def text=( text )
if text.kind_of? String
text = Text.new( text, whitespace(), nil, raw() )
@@ -509,17 +1105,45 @@ def text=( text )
return self
end
- # A helper method to add a Text child. Actual Text instances can
- # be added with regular Parent methods, such as add() and <<()
- # text::
- # if a String, a new Text instance is created and added
- # to the parent. If Text, the object is added directly.
- # Returns:: this Element
- # e = Element.new('a') #-> <e/>
- # e.add_text 'foo' #-> <e>foo</e>
- # e.add_text Text.new(' bar') #-> <e>foo bar</e>
- # Note that at the end of this example, the branch has <b>3</b> nodes; the 'e'
- # element and <b>2</b> Text node children.
+ # :call-seq:
+ # add_text(string) -> nil
+ # add_text(text_node) -> self
+ #
+ # Adds text to the element.
+ #
+ # When string argument +string+ is given, returns +nil+.
+ #
+ # If the element has no child text node,
+ # creates a \REXML::Text object using the string,
+ # honoring the current settings for whitespace and raw,
+ # then adds that node to the element:
+ #
+ # d = REXML::Document.new('<a><b/></a>')
+ # a = d.root
+ # a.add_text('foo')
+ # a.to_a # => [<b/>, "foo"]
+ #
+ # If the element has child text nodes,
+ # appends the string to the _last_ text node:
+ #
+ # d = REXML::Document.new('<a>foo<b/>bar</a>')
+ # a = d.root
+ # a.add_text('baz')
+ # a.to_a # => ["foo", <b/>, "barbaz"]
+ # a.add_text('baz')
+ # a.to_a # => ["foo", <b/>, "barbazbaz"]
+ #
+ # When text node argument +text_node+ is given,
+ # appends the node as the last text node in the element;
+ # returns +self+:
+ #
+ # d = REXML::Document.new('<a>foo<b/>bar</a>')
+ # a = d.root
+ # a.add_text(REXML::Text.new('baz'))
+ # a.to_a # => ["foo", <b/>, "bar", "baz"]
+ # a.add_text(REXML::Text.new('baz'))
+ # a.to_a # => ["foo", <b/>, "bar", "baz", "baz"]
+ #
def add_text( text )
if text.kind_of? String
if @children[-1].kind_of? Text
@@ -532,10 +1156,39 @@ def add_text( text )
return self
end
+ # :call-seq:
+ # node_type -> :element
+ #
+ # Returns symbol <tt>:element</tt>:
+ #
+ # d = REXML::Document.new('<a/>')
+ # a = d.root # => <a/>
+ # a.node_type # => :element
+ #
def node_type
:element
end
+ # :call-seq:
+ # xpath -> string_xpath
+ #
+ # Returns the string xpath to the element
+ # relative to the most distant parent:
+ #
+ # d = REXML::Document.new('<a><b><c/></b></a>')
+ # a = d.root # => <a> ... </>
+ # b = a[0] # => <b> ... </>
+ # c = b[0] # => <c/>
+ # d.xpath # => ""
+ # a.xpath # => "/a"
+ # b.xpath # => "/a/b"
+ # c.xpath # => "/a/b/c"
+ #
+ # If there is no parent, returns the expanded name of the element:
+ #
+ # e = REXML::Element.new('foo')
+ # e.xpath # => "foo"
+ #
def xpath
path_elements = []
cur = self
@@ -551,19 +1204,45 @@ def xpath
# Attributes #
#################################################
- # Fetches an attribute value or a child.
+ # :call-seq:
+ # [index] -> object
+ # [attr_name] -> attr_value
+ # [attr_sym] -> attr_value
+ #
+ # With integer argument +index+ given,
+ # returns the child at offset +index+, or +nil+ if none:
+ #
+ # d = REXML::Document.new '><root><a/>text<b/>more<c/></root>'
+ # root = d.root
+ # (0..root.size).each do |index|
+ # node = root[index]
+ # p "#{index}: #{node} (#{node.class})"
+ # end
+ #
+ # Output:
+ #
+ # "0: <a/> (REXML::Element)"
+ # "1: text (REXML::Text)"
+ # "2: <b/> (REXML::Element)"
+ # "3: more (REXML::Text)"
+ # "4: <c/> (REXML::Element)"
+ # "5: (NilClass)"
#
- # If String or Symbol is specified, it's treated as attribute
- # name. Attribute value as String or +nil+ is returned. This case
- # is shortcut of +attributes[name]+.
+ # With string argument +attr_name+ given,
+ # returns the string value for the given attribute name if it exists,
+ # otherwise +nil+:
#
- # If Integer is specified, it's treated as the index of
- # child. It returns Nth child.
+ # d = REXML::Document.new('<root attr="value"></root>')
+ # root = d.root
+ # root['attr'] # => "value"
+ # root['nosuch'] # => nil
+ #
+ # With symbol argument +attr_sym+ given,
+ # returns <tt>[attr_sym.to_s]</tt>:
+ #
+ # root[:attr] # => "value"
+ # root[:nosuch] # => nil
#
- # doc = REXML::Document.new("<a attr='1'><b/><c/></a>")
- # doc.root["attr"] # => "1"
- # doc.root.attributes["attr"] # => "1"
- # doc.root[1] # => <c/>
def [](name_or_index)
case name_or_index
when String
@@ -575,17 +1254,42 @@ def [](name_or_index)
end
end
+
+ # :call-seq:
+ # attribute(name, namespace = nil)
+ #
+ # Returns the string value for the given attribute name.
+ #
+ # With only argument +name+ given,
+ # returns the value of the named attribute if it exists, otherwise +nil+:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns="ns0">
+ # <a xmlns="ns1" attr="value"></a>
+ # <b xmlns="ns2" attr="value"></b>
+ # <c attr="value"/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # root = d.root
+ # a = root[1] # => <a xmlns='ns1' attr='value'/>
+ # a.attribute('attr') # => attr='value'
+ # a.attribute('nope') # => nil
+ #
+ # With arguments +name+ and +namespace+ given,
+ # returns the value of the named attribute if it exists, otherwise +nil+:
+ #
+ # xml_string = "<root xmlns:a='a' a:x='a:x' x='x'/>"
+ # document = REXML::Document.new(xml_string)
+ # document.root.attribute("x") # => x='x'
+ # document.root.attribute("x", "a") # => a:x='a:x'
+ #
def attribute( name, namespace=nil )
- prefix = nil
- if namespaces.respond_to? :key
- prefix = namespaces.key(namespace) if namespace
- else
- prefix = namespaces.index(namespace) if namespace
- end
+ prefix = namespaces.key(namespace) if namespace
prefix = nil if prefix == 'xmlns'
ret_val =
- attributes.get_attribute( "#{prefix ? prefix + ':' : ''}#{name}" )
+ attributes.get_attribute( prefix ? "#{prefix}:#{name}" : name )
return ret_val unless ret_val.nil?
return nil if prefix.nil?
@@ -598,29 +1302,46 @@ def attribute( name, namespace=nil )
end
- # Evaluates to +true+ if this element has any attributes set, false
- # otherwise.
+ # :call-seq:
+ # has_attributes? -> true or false
+ #
+ # Returns +true+ if the element has attributes, +false+ otherwise:
+ #
+ # d = REXML::Document.new('<root><a attr="val"/><b/></root>')
+ # a, b = *d.root
+ # a.has_attributes? # => true
+ # b.has_attributes? # => false
+ #
def has_attributes?
return !@attributes.empty?
end
+ # :call-seq:
+ # add_attribute(name, value) -> value
+ # add_attribute(attribute) -> attribute
+ #
# Adds an attribute to this element, overwriting any existing attribute
# by the same name.
- # key::
- # can be either an Attribute or a String. If an Attribute,
- # the attribute is added to the list of Element attributes. If String,
- # the argument is used as the name of the new attribute, and the value
- # parameter must be supplied.
- # value::
- # Required if +key+ is a String, and ignored if the first argument is
- # an Attribute. This is a String, and is used as the value
- # of the new Attribute. This should be the unnormalized value of the
- # attribute (without entities).
- # Returns:: the Attribute added
- # e = Element.new 'e'
- # e.add_attribute( 'a', 'b' ) #-> <e a='b'/>
- # e.add_attribute( 'x:a', 'c' ) #-> <e a='b' x:a='c'/>
- # e.add_attribute Attribute.new('b', 'd') #-> <e a='b' x:a='c' b='d'/>
+ #
+ # With string argument +name+ and object +value+ are given,
+ # adds the attribute created with that name and value:
+ #
+ # e = REXML::Element.new
+ # e.add_attribute('attr', 'value') # => "value"
+ # e['attr'] # => "value"
+ # e.add_attribute('attr', 'VALUE') # => "VALUE"
+ # e['attr'] # => "VALUE"
+ #
+ # With only attribute object +attribute+ given,
+ # adds the given attribute:
+ #
+ # a = REXML::Attribute.new('attr', 'value')
+ # e.add_attribute(a) # => attr='value'
+ # e['attr'] # => "value"
+ # a = REXML::Attribute.new('attr', 'VALUE')
+ # e.add_attribute(a) # => attr='VALUE'
+ # e['attr'] # => "VALUE"
+ #
def add_attribute( key, value=nil )
if key.kind_of? Attribute
@attributes << key
@@ -629,10 +1350,29 @@ def add_attribute( key, value=nil )
end
end
- # Add multiple attributes to this element.
- # hash:: is either a hash, or array of arrays
- # el.add_attributes( {"name1"=>"value1", "name2"=>"value2"} )
- # el.add_attributes( [ ["name1","value1"], ["name2"=>"value2"] ] )
+ # :call-seq:
+ # add_attributes(hash) -> hash
+ # add_attributes(array)
+ #
+ # Adds zero or more attributes to the element;
+ # returns the argument.
+ #
+ # If hash argument +hash+ is given,
+ # each key must be a string;
+ # adds each attribute created with the key/value pair:
+ #
+ # e = REXML::Element.new
+ # h = {'foo' => 'bar', 'baz' => 'bat'}
+ # e.add_attributes(h)
+ #
+ # If argument +array+ is given,
+ # each array member must be a 2-element array <tt>[name, value];
+ # each name must be a string:
+ #
+ # e = REXML::Element.new
+ # a = [['foo' => 'bar'], ['baz' => 'bat']]
+ # e.add_attributes(a)
+ #
def add_attributes hash
if hash.kind_of? Hash
hash.each_pair {|key, value| @attributes[key] = value }
@@ -641,19 +1381,17 @@ def add_attributes hash
end
end
- # Removes an attribute
- # key::
- # either an Attribute or a String. In either case, the
- # attribute is found by matching the attribute name to the argument,
- # and then removed. If no attribute is found, no action is taken.
- # Returns::
- # the attribute removed, or nil if this Element did not contain
- # a matching attribute
- # e = Element.new('E')
- # e.add_attribute( 'name', 'Sean' ) #-> <E name='Sean'/>
- # r = e.add_attribute( 'sur:name', 'Russell' ) #-> <E name='Sean' sur:name='Russell'/>
- # e.delete_attribute( 'name' ) #-> <E sur:name='Russell'/>
- # e.delete_attribute( r ) #-> <E/>
+ # :call-seq:
+ # delete_attribute(name) -> removed_attribute or nil
+ #
+ # Removes a named attribute if it exists;
+ # returns the removed attribute if found, otherwise +nil+:
+ #
+ # e = REXML::Element.new('foo')
+ # e.add_attribute('bar', 'baz')
+ # e.delete_attribute('bar') # => <bar/>
+ # e.delete_attribute('bar') # => nil
+ #
def delete_attribute(key)
attr = @attributes.get_attribute(key)
attr.remove unless attr.nil?
@@ -663,26 +1401,80 @@ def delete_attribute(key)
# Other Utilities #
#################################################
- # Get an array of all CData children.
- # IMMUTABLE
+ # :call-seq:
+ # cdatas -> array_of_cdata_children
+ #
+ # Returns a frozen array of the REXML::CData children of the element:
+ #
+ # xml_string = <<-EOT
+ # <root>
+ # <![CDATA[foo]]>
+ # <![CDATA[bar]]>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # cds = d.root.cdatas # => ["foo", "bar"]
+ # cds.frozen? # => true
+ # cds.map {|cd| cd.class } # => [REXML::CData, REXML::CData]
+ #
def cdatas
find_all { |child| child.kind_of? CData }.freeze
end
- # Get an array of all Comment children.
- # IMMUTABLE
+ # :call-seq:
+ # comments -> array_of_comment_children
+ #
+ # Returns a frozen array of the REXML::Comment children of the element:
+ #
+ # xml_string = <<-EOT
+ # <root>
+ # <!--foo-->
+ # <!--bar-->
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # cs = d.root.comments
+ # cs.frozen? # => true
+ # cs.map {|c| c.class } # => [REXML::Comment, REXML::Comment]
+ # cs.map {|c| c.to_s } # => ["foo", "bar"]
+ #
def comments
find_all { |child| child.kind_of? Comment }.freeze
end
- # Get an array of all Instruction children.
- # IMMUTABLE
+ # :call-seq:
+ # instructions -> array_of_instruction_children
+ #
+ # Returns a frozen array of the REXML::Instruction children of the element:
+ #
+ # xml_string = <<-EOT
+ # <root>
+ # <?target0 foo?>
+ # <?target1 bar?>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # is = d.root.instructions
+ # is.frozen? # => true
+ # is.map {|i| i.class } # => [REXML::Instruction, REXML::Instruction]
+ # is.map {|i| i.to_s } # => ["<?target0 foo?>", "<?target1 bar?>"]
+ #
def instructions
find_all { |child| child.kind_of? Instruction }.freeze
end
- # Get an array of all Text children.
- # IMMUTABLE
+ # :call-seq:
+ # texts -> array_of_text_children
+ #
+ # Returns a frozen array of the REXML::Text children of the element:
+ #
+ # xml_string = '<root><a/>text<b/>more<c/></root>'
+ # d = REXML::Document.new(xml_string)
+ # ts = d.root.texts
+ # ts.frozen? # => true
+ # ts.map {|t| t.class } # => [REXML::Text, REXML::Text]
+ # ts.map {|t| t.to_s } # => ["text", "more"]
+ #
def texts
find_all { |child| child.kind_of? Text }.freeze
end
@@ -713,7 +1505,7 @@ def write(output=$stdout, indent=-1, transitive=false, ie_hack=false)
Kernel.warn("#{self.class.name}.write is deprecated. See REXML::Formatters", uplevel: 1)
formatter = if indent > -1
if transitive
- require "rexml/formatters/transitive"
+ require_relative "formatters/transitive"
REXML::Formatters::Transitive.new( indent, ie_hack )
else
REXML::Formatters::Pretty.new( indent, ie_hack )
@@ -758,35 +1550,129 @@ def each_with_something( test, max=0, name=nil )
# XPath search support. You are expected to only encounter this class as
# the <tt>element.elements</tt> object. Therefore, you are
# _not_ expected to instantiate this yourself.
+ #
+ # xml_string = <<-EOT
+ # <?xml version="1.0" encoding="UTF-8"?>
+ # <bookstore>
+ # <book category="cooking">
+ # <title lang="en">Everyday Italian</title>
+ # <author>Giada De Laurentiis</author>
+ # <year>2005</year>
+ # <price>30.00</price>
+ # </book>
+ # <book category="children">
+ # <title lang="en">Harry Potter</title>
+ # <author>J K. Rowling</author>
+ # <year>2005</year>
+ # <price>29.99</price>
+ # </book>
+ # <book category="web">
+ # <title lang="en">XQuery Kick Start</title>
+ # <author>James McGovern</author>
+ # <author>Per Bothner</author>
+ # <author>Kurt Cagle</author>
+ # <author>James Linn</author>
+ # <author>Vaidyanathan Nagarajan</author>
+ # <year>2003</year>
+ # <price>49.99</price>
+ # </book>
+ # <book category="web" cover="paperback">
+ # <title lang="en">Learning XML</title>
+ # <author>Erik T. Ray</author>
+ # <year>2003</year>
+ # <price>39.95</price>
+ # </book>
+ # </bookstore>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements # => #<REXML::Elements @element=<bookstore> ... </>>
+ #
class Elements
include Enumerable
- # Constructor
- # parent:: the parent Element
+ # :call-seq:
+ # new(parent) -> new_elements_object
+ #
+ # Returns a new \Elements object with the given +parent+.
+ # Does _not_ assign <tt>parent.elements = self</tt>:
+ #
+ # d = REXML::Document.new(xml_string)
+ # eles = REXML::Elements.new(d.root)
+ # eles # => #<REXML::Elements @element=<bookstore> ... </>>
+ # eles == d.root.elements # => false
+ #
def initialize parent
@element = parent
end
- # Fetches a child element. Filters only Element children, regardless of
- # the XPath match.
- # index::
- # the search parameter. This is either an Integer, which
- # will be used to find the index'th child Element, or an XPath,
- # which will be used to search for the Element. <em>Because
- # of the nature of XPath searches, any element in the connected XML
- # document can be fetched through any other element.</em> <b>The
- # Integer index is 1-based, not 0-based.</b> This means that the first
- # child element is at index 1, not 0, and the +n+th element is at index
- # +n+, not <tt>n-1</tt>. This is because XPath indexes element children
- # starting from 1, not 0, and the indexes should be the same.
- # name::
- # optional, and only used in the first argument is an
- # Integer. In that case, the index'th child Element that has the
- # supplied name will be returned. Note again that the indexes start at 1.
- # Returns:: the first matching Element, or nil if no child matched
- # doc = Document.new '<a><b/><c id="1"/><c id="2"/><d/></a>'
- # doc.root.elements[1] #-> <b/>
- # doc.root.elements['c'] #-> <c id="1"/>
- # doc.root.elements[2,'c'] #-> <c id="2"/>
+ # :call-seq:
+ # parent
+ #
+ # Returns the parent element cited in creating the \Elements object.
+ # This element is also the default starting point for searching
+ # in the \Elements object.
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = REXML::Elements.new(d.root)
+ # elements.parent == d.root # => true
+ #
+ def parent
+ @element
+ end
+
+ # :call-seq:
+ # elements[index] -> element or nil
+ # elements[xpath] -> element or nil
+ # elements[n, name] -> element or nil
+ #
+ # Returns the first \Element object selected by the arguments,
+ # if any found, or +nil+ if none found.
+ #
+ # Notes:
+ # - The +index+ is 1-based, not 0-based, so that:
+ # - The first element has index <tt>1</tt>
+ # - The _nth_ element has index +n+.
+ # - The selection ignores non-\Element nodes.
+ #
+ # When the single argument +index+ is given,
+ # returns the element given by the index, if any; otherwise, +nil+:
+ #
+ # d = REXML::Document.new(xml_string)
+ # eles = d.root.elements
+ # eles # => #<REXML::Elements @element=<bookstore> ... </>>
+ # eles[1] # => <book category='cooking'> ... </>
+ # eles.size # => 4
+ # eles[4] # => <book category='web' cover='paperback'> ... </>
+ # eles[5] # => nil
+ #
+ # The node at this index is not an \Element, and so is not returned:
+ #
+ # eles = d.root.first.first # => <title lang='en'> ... </>
+ # eles.to_a # => ["Everyday Italian"]
+ # eles[1] # => nil
+ #
+ # When the single argument +xpath+ is given,
+ # returns the first element found via that +xpath+, if any; otherwise, +nil+:
+ #
+ # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>>
+ # eles['/bookstore'] # => <bookstore> ... </>
+ # eles['//book'] # => <book category='cooking'> ... </>
+ # eles['//book [@category="children"]'] # => <book category='children'> ... </>
+ # eles['/nosuch'] # => nil
+ # eles['//nosuch'] # => nil
+ # eles['//book [@category="nosuch"]'] # => nil
+ # eles['.'] # => <bookstore> ... </>
+ # eles['..'].class # => REXML::Document
+ #
+ # With arguments +n+ and +name+ given,
+ # returns the _nth_ found element that has the given +name+,
+ # or +nil+ if there is no such _nth_ element:
+ #
+ # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>>
+ # eles[1, 'book'] # => <book category='cooking'> ... </>
+ # eles[4, 'book'] # => <book category='web' cover='paperback'> ... </>
+ # eles[5, 'book'] # => nil
+ #
def []( index, name=nil)
if index.kind_of? Integer
raise "index (#{index}) must be >= 1" if index < 1
@@ -806,19 +1692,42 @@ def []( index, name=nil)
end
end
- # Sets an element, replacing any previous matching element. If no
- # existing element is found ,the element is added.
- # index:: Used to find a matching element to replace. See []().
- # element::
- # The element to replace the existing element with
- # the previous element
- # Returns:: nil if no previous element was found.
+ # :call-seq:
+ # elements[] = index, replacement_element -> replacement_element or nil
+ #
+ # Replaces or adds an element.
+ #
+ # When <tt>eles[index]</tt> exists, replaces it with +replacement_element+
+ # and returns +replacement_element+:
+ #
+ # d = REXML::Document.new(xml_string)
+ # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>>
+ # eles[1] # => <book category='cooking'> ... </>
+ # eles[1] = REXML::Element.new('foo')
+ # eles[1] # => <foo/>
+ #
+ # Does nothing (or raises an exception)
+ # if +replacement_element+ is not an \Element:
+ # eles[2] # => <book category='web' cover='paperback'> ... </>
+ # eles[2] = REXML::Text.new('bar')
+ # eles[2] # => <book category='web' cover='paperback'> ... </>
+ #
+ # When <tt>eles[index]</tt> does not exist,
+ # adds +replacement_element+ to the element and returns
+ #
+ # d = REXML::Document.new(xml_string)
+ # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>>
+ # eles.size # => 4
+ # eles[50] = REXML::Element.new('foo') # => <foo/>
+ # eles.size # => 5
+ # eles[5] # => <foo/>
+ #
+ # Does nothing (or raises an exception)
+ # if +replacement_element+ is not an \Element:
+ #
+ # eles[50] = REXML::Text.new('bar') # => "bar"
+ # eles.size # => 5
#
- # doc = Document.new '<a/>'
- # doc.root.elements[10] = Element.new('b') #-> <a><b/></a>
- # doc.root.elements[1] #-> <b/>
- # doc.root.elements[1] = Element.new('c') #-> <a><c/></a>
- # doc.root.elements['c'] = Element.new('d') #-> <a><d/></a>
def []=( index, element )
previous = self[index]
if previous.nil?
@@ -829,14 +1738,34 @@ def []=( index, element )
return previous
end
- # Returns +true+ if there are no +Element+ children, +false+ otherwise
+ # :call-seq:
+ # empty? -> true or false
+ #
+ # Returns +true+ if there are no children, +false+ otherwise.
+ #
+ # d = REXML::Document.new('')
+ # d.elements.empty? # => true
+ # d = REXML::Document.new(xml_string)
+ # d.elements.empty? # => false
+ #
def empty?
@element.find{ |child| child.kind_of? Element}.nil?
end
- # Returns the index of the supplied child (starting at 1), or -1 if
- # the element is not a child
- # element:: an +Element+ child
+ # :call-seq:
+ # index(element)
+ #
+ # Returns the 1-based index of the given +element+, if found;
+ # otherwise, returns -1:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # ele_1, ele_2, ele_3, ele_4 = *elements
+ # elements.index(ele_4) # => 4
+ # elements.delete(ele_3)
+ # elements.index(ele_4) # => 3
+ # elements.index(ele_3) # => -1
+ #
def index element
rv = 0
found = @element.find do |child|
@@ -848,17 +1777,47 @@ def index element
return -1
end
- # Deletes a child Element
- # element::
- # Either an Element, which is removed directly; an
- # xpath, where the first matching child is removed; or an Integer,
- # where the n'th Element is removed.
- # Returns:: the removed child
- # doc = Document.new '<a><b/><c/><c id="1"/></a>'
- # b = doc.root.elements[1]
- # doc.root.elements.delete b #-> <a><c/><c id="1"/></a>
- # doc.elements.delete("a/c[@id='1']") #-> <a><c/></a>
- # doc.root.elements.delete 1 #-> <a/>
+ # :call-seq:
+ # delete(index) -> removed_element or nil
+ # delete(element) -> removed_element or nil
+ # delete(xpath) -> removed_element or nil
+ #
+ # Removes an element; returns the removed element, or +nil+ if none removed.
+ #
+ # With integer argument +index+ given,
+ # removes the child element at that offset:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.size # => 4
+ # elements[2] # => <book category='children'> ... </>
+ # elements.delete(2) # => <book category='children'> ... </>
+ # elements.size # => 3
+ # elements[2] # => <book category='web'> ... </>
+ # elements.delete(50) # => nil
+ #
+ # With element argument +element+ given,
+ # removes that child element:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # ele_1, ele_2, ele_3, ele_4 = *elements
+ # elements.size # => 4
+ # elements[2] # => <book category='children'> ... </>
+ # elements.delete(ele_2) # => <book category='children'> ... </>
+ # elements.size # => 3
+ # elements[2] # => <book category='web'> ... </>
+ # elements.delete(ele_2) # => nil
+ #
+ # With string argument +xpath+ given,
+ # removes the first element found via that xpath:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.delete('//book') # => <book category='cooking'> ... </>
+ # elements.delete('//book [@category="children"]') # => <book category='children'> ... </>
+ # elements.delete('//nosuch') # => nil
+ #
def delete element
if element.kind_of? Element
@element.delete element
@@ -868,12 +1827,23 @@ def delete element
end
end
- # Removes multiple elements. Filters for Element children, regardless of
- # XPath matching.
- # xpath:: all elements matching this String path are removed.
- # Returns:: an Array of Elements that have been removed
- # doc = Document.new '<a><c/><c/><c/><c/></a>'
- # deleted = doc.elements.delete_all 'a/c' #-> [<c/>, <c/>, <c/>, <c/>]
+ # :call-seq:
+ # delete_all(xpath)
+ #
+ # Removes all elements found via the given +xpath+;
+ # returns the array of removed elements, if any, else +nil+.
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.size # => 4
+ # deleted_elements = elements.delete_all('//book [@category="web"]')
+ # deleted_elements.size # => 2
+ # elements.size # => 2
+ # deleted_elements = elements.delete_all('//book')
+ # deleted_elements.size # => 2
+ # elements.size # => 0
+ # elements.delete_all('//book') # => []
+ #
def delete_all( xpath )
rv = []
XPath::each( @element, xpath) {|element|
@@ -886,15 +1856,68 @@ def delete_all( xpath )
return rv
end
- # Adds an element
- # element::
- # if supplied, is either an Element, String, or
- # Source (see Element.initialize). If not supplied or nil, a
- # new, default Element will be constructed
- # Returns:: the added Element
- # a = Element.new('a')
- # a.elements.add(Element.new('b')) #-> <a><b/></a>
- # a.elements.add('c') #-> <a><b/><c/></a>
+ # :call-seq:
+ # add -> new_element
+ # add(name) -> new_element
+ # add(element) -> element
+ #
+ # Adds an element; returns the element added.
+ #
+ # With no argument, creates and adds a new element.
+ # The new element has:
+ #
+ # - No name.
+ # - \Parent from the \Elements object.
+ # - Context from the that parent.
+ #
+ # Example:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # parent = elements.parent # => <bookstore> ... </>
+ # parent.context = {raw: :all}
+ # elements.size # => 4
+ # new_element = elements.add # => </>
+ # elements.size # => 5
+ # new_element.name # => nil
+ # new_element.parent # => <bookstore> ... </>
+ # new_element.context # => {:raw=>:all}
+ #
+ # With string argument +name+, creates and adds a new element.
+ # The new element has:
+ #
+ # - Name +name+.
+ # - \Parent from the \Elements object.
+ # - Context from the that parent.
+ #
+ # Example:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # parent = elements.parent # => <bookstore> ... </>
+ # parent.context = {raw: :all}
+ # elements.size # => 4
+ # new_element = elements.add('foo') # => <foo/>
+ # elements.size # => 5
+ # new_element.name # => "foo"
+ # new_element.parent # => <bookstore> ... </>
+ # new_element.context # => {:raw=>:all}
+ #
+ # With argument +element+,
+ # creates and adds a clone of the given +element+.
+ # The new element has name, parent, and context from the given +element+.
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.size # => 4
+ # e0 = REXML::Element.new('foo')
+ # e1 = REXML::Element.new('bar', e0, {raw: :all})
+ # element = elements.add(e1) # => <bar/>
+ # elements.size # => 5
+ # element.name # => "bar"
+ # element.parent # => <bookstore> ... </>
+ # element.context # => {:raw=>:all}
+ #
def add element=nil
if element.nil?
Element.new("", self, @element.context)
@@ -909,24 +1932,55 @@ def add element=nil
alias :<< :add
- # Iterates through all of the child Elements, optionally filtering
- # them by a given XPath
- # xpath::
- # optional. If supplied, this is a String XPath, and is used to
- # filter the children, so that only matching children are yielded. Note
- # that XPaths are automatically filtered for Elements, so that
- # non-Element children will not be yielded
- # doc = Document.new '<a><b/><c/><d/>sean<b/><c/><d/></a>'
- # doc.root.elements.each {|e|p e} #-> Yields b, c, d, b, c, d elements
- # doc.root.elements.each('b') {|e|p e} #-> Yields b, b elements
- # doc.root.elements.each('child::node()') {|e|p e}
- # #-> Yields <b/>, <c/>, <d/>, <b/>, <c/>, <d/>
- # XPath.each(doc.root, 'child::node()', &block)
- # #-> Yields <b/>, <c/>, <d/>, sean, <b/>, <c/>, <d/>
+ # :call-seq:
+ # each(xpath = nil) {|element| ... } -> self
+ #
+ # Iterates over the elements.
+ #
+ # With no argument, calls the block with each element:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.each {|element| p element }
+ #
+ # Output:
+ #
+ # <book category='cooking'> ... </>
+ # <book category='children'> ... </>
+ # <book category='web'> ... </>
+ # <book category='web' cover='paperback'> ... </>
+ #
+ # With argument +xpath+, calls the block with each element
+ # that matches the given +xpath+:
+ #
+ # elements.each('//book [@category="web"]') {|element| p element }
+ #
+ # Output:
+ #
+ # <book category='web'> ... </>
+ # <book category='web' cover='paperback'> ... </>
+ #
def each( xpath=nil )
XPath::each( @element, xpath ) {|e| yield e if e.kind_of? Element }
end
+ # :call-seq:
+ # collect(xpath = nil) {|element| ... } -> array
+ #
+ # Iterates over the elements; returns the array of block return values.
+ #
+ # With no argument, iterates over all elements:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.collect {|element| element.size } # => [9, 9, 17, 9]
+ #
+ # With argument +xpath+, iterates over elements that match
+ # the given +xpath+:
+ #
+ # xpath = '//book [@category="web"]'
+ # elements.collect(xpath) {|element| element.size } # => [17, 9]
+ #
def collect( xpath=nil )
collection = []
XPath::each( @element, xpath ) {|e|
@@ -935,6 +1989,83 @@ def collect( xpath=nil )
collection
end
+ # :call-seq:
+ # inject(xpath = nil, initial = nil) -> object
+ #
+ # Calls the block with elements; returns the last block return value.
+ #
+ # With no argument, iterates over the elements, calling the block
+ # <tt>elements.size - 1</tt> times.
+ #
+ # - The first call passes the first and second elements.
+ # - The second call passes the first block return value and the third element.
+ # - The third call passes the second block return value and the fourth element.
+ # - And so on.
+ #
+ # In this example, the block returns the passed element,
+ # which is then the object argument to the next call:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.inject do |object, element|
+ # p [elements.index(object), elements.index(element)]
+ # element
+ # end
+ #
+ # Output:
+ #
+ # [1, 2]
+ # [2, 3]
+ # [3, 4]
+ #
+ # With the single argument +xpath+, calls the block only with
+ # elements matching that xpath:
+ #
+ # elements.inject('//book [@category="web"]') do |object, element|
+ # p [elements.index(object), elements.index(element)]
+ # element
+ # end
+ #
+ # Output:
+ #
+ # [3, 4]
+ #
+ # With argument +xpath+ given as +nil+
+ # and argument +initial+ also given,
+ # calls the block once for each element.
+ #
+ # - The first call passes the +initial+ and the first element.
+ # - The second call passes the first block return value and the second element.
+ # - The third call passes the second block return value and the third element.
+ # - And so on.
+ #
+ # In this example, the first object index is <tt>-1</tt>
+ #
+ # elements.inject(nil, 'Initial') do |object, element|
+ # p [elements.index(object), elements.index(element)]
+ # element
+ # end
+ #
+ # Output:
+ #
+ # [-1, 1]
+ # [1, 2]
+ # [2, 3]
+ # [3, 4]
+ #
+ # In this form the passed object can be used as an accumulator:
+ #
+ # elements.inject(nil, 0) do |total, element|
+ # total += element.size
+ # end # => 44
+ #
+ # With both arguments +xpath+ and +initial+ are given,
+ # calls the block only with elements matching that xpath:
+ #
+ # elements.inject('//book [@category="web"]', 0) do |total, element|
+ # total += element.size
+ # end # => 26
+ #
def inject( xpath=nil, initial=nil )
first = true
XPath::each( @element, xpath ) {|e|
@@ -950,23 +2081,39 @@ def inject( xpath=nil, initial=nil )
initial
end
- # Returns the number of +Element+ children of the parent object.
- # doc = Document.new '<a>sean<b/>elliott<b/>russell<b/></a>'
- # doc.root.size #-> 6, 3 element and 3 text nodes
- # doc.root.elements.size #-> 3
+ # :call-seq:
+ # size -> integer
+ #
+ # Returns the count of \Element children:
+ #
+ # d = REXML::Document.new '<a>sean<b/>elliott<b/>russell<b/></a>'
+ # d.root.elements.size # => 3 # Three elements.
+ # d.root.size # => 6 # Three elements plus three text nodes..
+ #
def size
count = 0
@element.each {|child| count+=1 if child.kind_of? Element }
count
end
- # Returns an Array of Element children. An XPath may be supplied to
- # filter the children. Only Element children are returned, even if the
- # supplied XPath matches non-Element children.
- # doc = Document.new '<a>sean<b/>elliott<c/></a>'
- # doc.root.elements.to_a #-> [ <b/>, <c/> ]
- # doc.root.elements.to_a("child::node()") #-> [ <b/>, <c/> ]
- # XPath.match(doc.root, "child::node()") #-> [ sean, <b/>, elliott, <c/> ]
+ # :call-seq:
+ # to_a(xpath = nil) -> array_of_elements
+ #
+ # Returns an array of element children (not including non-element children).
+ #
+ # With no argument, returns an array of all element children:
+ #
+ # d = REXML::Document.new '<a>sean<b/>elliott<c/></a>'
+ # elements = d.root.elements
+ # elements.to_a # => [<b/>, <c/>] # Omits non-element children.
+ # children = d.root.children
+ # children # => ["sean", <b/>, "elliott", <c/>] # Includes non-element children.
+ #
+ # With argument +xpath+, returns an array of element children
+ # that match the xpath:
+ #
+ # elements.to_a('//c') # => [<c/>]
+ #
def to_a( xpath=nil )
rv = XPath.match( @element, xpath )
return rv.find_all{|e| e.kind_of? Element} if xpath
@@ -988,36 +2135,89 @@ def literalize name
# A class that defines the set of Attributes of an Element and provides
# operations for accessing elements in that set.
class Attributes < Hash
- # Constructor
- # element:: the Element of which this is an Attribute
+
+ # :call-seq:
+ # new(element)
+ #
+ # Creates and returns a new \REXML::Attributes object.
+ # The element given by argument +element+ is stored,
+ # but its own attributes are not modified:
+ #
+ # ele = REXML::Element.new('foo')
+ # attrs = REXML::Attributes.new(ele)
+ # attrs.object_id == ele.attributes.object_id # => false
+ #
+ # Other instance methods in class \REXML::Attributes may refer to:
+ #
+ # - +element.document+.
+ # - +element.prefix+.
+ # - +element.expanded_name+.
+ #
def initialize element
@element = element
end
- # Fetches an attribute value. If you want to get the Attribute itself,
- # use get_attribute()
- # name:: an XPath attribute name. Namespaces are relevant here.
- # Returns::
- # the String value of the matching attribute, or +nil+ if no
- # matching attribute was found. This is the unnormalized value
- # (with entities expanded).
+ # :call-seq:
+ # [name] -> attribute_value or nil
+ #
+ # Returns the value for the attribute given by +name+,
+ # if it exists; otherwise +nil+.
+ # The value returned is the unnormalized attribute value,
+ # with entities expanded:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # ele.attributes['att'] # => "<"
+ # ele.attributes['bar:att'] # => "2"
+ # ele.attributes['nosuch'] # => nil
+ #
+ # Related: get_attribute (returns an \Attribute object).
#
- # doc = Document.new "<a foo:att='1' bar:att='2' att='<'/>"
- # doc.root.attributes['att'] #-> '<'
- # doc.root.attributes['bar:att'] #-> '2'
def [](name)
attr = get_attribute(name)
return attr.value unless attr.nil?
return nil
end
+ # :call-seq:
+ # to_a -> array_of_attribute_objects
+ #
+ # Returns an array of \REXML::Attribute objects representing
+ # the attributes:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes.to_a # => [foo:att='1', bar:att='2', att='<']
+ # attrs.first.class # => REXML::Attribute
+ #
def to_a
enum_for(:each_attribute).to_a
end
- # Returns the number of attributes the owning Element contains.
- # doc = Document "<a x='1' y='2' foo:x='3'/>"
- # doc.root.attributes.length #-> 3
+ # :call-seq:
+ # length
+ #
+ # Returns the count of attributes:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # ele.attributes.length # => 3
+ #
def length
c = 0
each_attribute { c+=1 }
@@ -1025,14 +2225,30 @@ def length
end
alias :size :length
- # Iterates over the attributes of an Element. Yields actual Attribute
- # nodes, not String values.
+ # :call-seq:
+ # each_attribute {|attr| ... }
+ #
+ # Calls the given block with each \REXML::Attribute object:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # ele.attributes.each_attribute do |attr|
+ # p [attr.class, attr]
+ # end
+ #
+ # Output:
+ #
+ # [REXML::Attribute, foo:att='1']
+ # [REXML::Attribute, bar:att='2']
+ # [REXML::Attribute, att='<']
#
- # doc = Document.new '<a x="1" y="2"/>'
- # doc.root.attributes.each_attribute {|attr|
- # p attr.expanded_name+" => "+attr.value
- # }
def each_attribute # :yields: attribute
+ return to_enum(__method__) unless block_given?
each_value do |val|
if val.kind_of? Attribute
yield val
@@ -1042,26 +2258,54 @@ def each_attribute # :yields: attribute
end
end
- # Iterates over each attribute of an Element, yielding the expanded name
- # and value as a pair of Strings.
+ # :call-seq:
+ # each {|expanded_name, value| ... }
+ #
+ # Calls the given block with each expanded-name/value pair:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # ele.attributes.each do |expanded_name, value|
+ # p [expanded_name, value]
+ # end
+ #
+ # Output:
+ #
+ # ["foo:att", "1"]
+ # ["bar:att", "2"]
+ # ["att", "<"]
#
- # doc = Document.new '<a x="1" y="2"/>'
- # doc.root.attributes.each {|name, value| p name+" => "+value }
def each
+ return to_enum(__method__) unless block_given?
each_attribute do |attr|
yield [attr.expanded_name, attr.value]
end
end
- # Fetches an attribute
- # name::
- # the name by which to search for the attribute. Can be a
- # <tt>prefix:name</tt> namespace name.
- # Returns:: The first matching attribute, or nil if there was none. This
- # value is an Attribute node, not the String value of the attribute.
- # doc = Document.new '<a x:foo="1" foo="2" bar="3"/>'
- # doc.root.attributes.get_attribute("foo").value #-> "2"
- # doc.root.attributes.get_attribute("x:foo").value #-> "1"
+ # :call-seq:
+ # get_attribute(name) -> attribute_object or nil
+ #
+ # Returns the \REXML::Attribute object for the given +name+:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs.get_attribute('foo:att') # => foo:att='1'
+ # attrs.get_attribute('foo:att').class # => REXML::Attribute
+ # attrs.get_attribute('bar:att') # => bar:att='2'
+ # attrs.get_attribute('att') # => att='<'
+ # attrs.get_attribute('nosuch') # => nil
+ #
def get_attribute( name )
attr = fetch( name, nil )
if attr.nil?
@@ -1095,18 +2339,29 @@ def get_attribute( name )
return attr
end
- # Sets an attribute, overwriting any existing attribute value by the
- # same name. Namespace is significant.
- # name:: the name of the attribute
- # value::
- # (optional) If supplied, the value of the attribute. If
- # nil, any existing matching attribute is deleted.
- # Returns::
- # Owning element
- # doc = Document.new "<a x:foo='1' foo='3'/>"
- # doc.root.attributes['y:foo'] = '2'
- # doc.root.attributes['foo'] = '4'
- # doc.root.attributes['x:foo'] = nil
+ # :call-seq:
+ # [name] = value -> value
+ #
+ # When +value+ is non-+nil+,
+ # assigns that to the attribute for the given +name+,
+ # overwriting the previous value if it exists:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs['foo:att'] = '2' # => "2"
+ # attrs['baz:att'] = '3' # => "3"
+ #
+ # When +value+ is +nil+, deletes the attribute if it exists:
+ #
+ # attrs['baz:att'] = nil
+ # attrs.include?('baz:att') # => false
+ #
def []=( name, value )
if value.nil? # Delete the named attribute
attr = get_attribute(name)
@@ -1129,29 +2384,25 @@ def []=( name, value )
elsif old_attr.kind_of? Hash
old_attr[value.prefix] = value
elsif old_attr.prefix != value.prefix
- # Check for conflicting namespaces
- raise ParseException.new(
- "Namespace conflict in adding attribute \"#{value.name}\": "+
- "Prefix \"#{old_attr.prefix}\" = "+
- "\"#{@element.namespace(old_attr.prefix)}\" and prefix "+
- "\"#{value.prefix}\" = \"#{@element.namespace(value.prefix)}\"") if
- value.prefix != "xmlns" and old_attr.prefix != "xmlns" and
- @element.namespace( old_attr.prefix ) ==
- @element.namespace( value.prefix )
- store value.name, { old_attr.prefix => old_attr,
- value.prefix => value }
+ store value.name, {old_attr.prefix => old_attr,
+ value.prefix => value}
else
store value.name, value
end
return @element
end
- # Returns an array of Strings containing all of the prefixes declared
- # by this set of # attributes. The array does not include the default
+ # :call-seq:
+ # prefixes -> array_of_prefix_strings
+ #
+ # Returns an array of prefix strings in the attributes.
+ # The array does not include the default
# namespace declaration, if one exists.
- # doc = Document.new("<a xmlns='foo' xmlns:x='bar' xmlns:y='twee' "+
- # "z='glorp' p:k='gru'/>")
- # prefixes = doc.root.attributes.prefixes #-> ['x', 'y']
+ #
+ # xml_string = '<a xmlns="foo" xmlns:x="bar" xmlns:y="twee" z="glorp"/>'
+ # d = REXML::Document.new(xml_string)
+ # d.root.attributes.prefixes # => ["x", "y"]
+ #
def prefixes
ns = []
each_attribute do |attribute|
@@ -1168,6 +2419,15 @@ def prefixes
ns
end
+ # :call-seq:
+ # namespaces
+ #
+ # Returns a hash of name/value pairs for the namespaces:
+ #
+ # xml_string = '<a xmlns="foo" xmlns:x="bar" xmlns:y="twee" z="glorp"/>'
+ # d = REXML::Document.new(xml_string)
+ # d.root.attributes.namespaces # => {"xmlns"=>"foo", "x"=>"bar", "y"=>"twee"}
+ #
def namespaces
namespaces = {}
each_attribute do |attribute|
@@ -1184,16 +2444,34 @@ def namespaces
namespaces
end
- # Removes an attribute
- # attribute::
- # either a String, which is the name of the attribute to remove --
- # namespaces are significant here -- or the attribute to remove.
- # Returns:: the owning element
- # doc = Document.new "<a y:foo='0' x:foo='1' foo='3' z:foo='4'/>"
- # doc.root.attributes.delete 'foo' #-> <a y:foo='0' x:foo='1' z:foo='4'/>"
- # doc.root.attributes.delete 'x:foo' #-> <a y:foo='0' z:foo='4'/>"
- # attr = doc.root.attributes.get_attribute('y:foo')
- # doc.root.attributes.delete attr #-> <a z:foo='4'/>"
+ # :call-seq:
+ # delete(name) -> element
+ # delete(attribute) -> element
+ #
+ # Removes a specified attribute if it exists;
+ # returns the attributes' element.
+ #
+ # When string argument +name+ is given,
+ # removes the attribute of that name if it exists:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs.delete('foo:att') # => <ele bar:att='2' att='<'/>
+ # attrs.delete('foo:att') # => <ele bar:att='2' att='<'/>
+ #
+ # When attribute argument +attribute+ is given,
+ # removes that attribute if it exists:
+ #
+ # attr = REXML::Attribute.new('bar:att', '2')
+ # attrs.delete(attr) # => <ele att='<'/> # => <ele att='<'/>
+ # attrs.delete(attr) # => <ele att='<'/> # => <ele/>
+ #
def delete( attribute )
name = nil
prefix = nil
@@ -1221,19 +2499,48 @@ def delete( attribute )
@element
end
- # Adds an attribute, overriding any existing attribute by the
- # same name. Namespaces are significant.
- # attribute:: An Attribute
+ # :call-seq:
+ # add(attribute) -> attribute
+ #
+ # Adds attribute +attribute+, replacing the previous
+ # attribute of the same name if it exists;
+ # returns +attribute+:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs # => {"att"=>{"foo"=>foo:att='1', "bar"=>bar:att='2', ""=>att='<'}}
+ # attrs.add(REXML::Attribute.new('foo:att', '2')) # => foo:att='2'
+ # attrs.add(REXML::Attribute.new('baz', '3')) # => baz='3'
+ # attrs.include?('baz') # => true
+ #
def add( attribute )
self[attribute.name] = attribute
end
alias :<< :add
- # Deletes all attributes matching a name. Namespaces are significant.
- # name::
- # A String; all attributes that match this path will be removed
- # Returns:: an Array of the Attributes that were removed
+ # :call-seq:
+ # delete_all(name) -> array_of_removed_attributes
+ #
+ # Removes all attributes matching the given +name+;
+ # returns an array of the removed attributes:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs.delete_all('att') # => [att='<']
+ #
def delete_all( name )
rv = []
each_attribute { |attribute|
@@ -1243,11 +2550,23 @@ def delete_all( name )
return rv
end
- # The +get_attribute_ns+ method retrieves a method by its namespace
- # and name. Thus it is possible to reliably identify an attribute
- # even if an XML processor has changed the prefix.
+ # :call-seq:
+ # get_attribute_ns(namespace, name)
+ #
+ # Returns the \REXML::Attribute object among the attributes
+ # that matches the given +namespace+ and +name+:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs.get_attribute_ns('http://foo', 'att') # => foo:att='1'
+ # attrs.get_attribute_ns('http://foo', 'nosuch') # => nil
#
- # Method contributed by Henrik Martensson
def get_attribute_ns(namespace, name)
result = nil
each_attribute() { |attribute|
diff --git a/lib/rexml/entity.rb b/lib/rexml/entity.rb
index 97c7b6b42f..1ba5a7bb7b 100644
--- a/lib/rexml/entity.rb
+++ b/lib/rexml/entity.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: false
-require 'rexml/child'
-require 'rexml/source'
-require 'rexml/xmltokens'
+require_relative 'child'
+require_relative 'source'
+require_relative 'xmltokens'
module REXML
class Entity < Child
@@ -12,6 +12,7 @@ class Entity < Child
EXTERNALID = "(?:(?:(SYSTEM)\\s+#{SYSTEMLITERAL})|(?:(PUBLIC)\\s+#{PUBIDLITERAL}\\s+#{SYSTEMLITERAL}))"
NDATADECL = "\\s+NDATA\\s+#{NAME}"
PEREFERENCE = "%#{NAME};"
+ PEREFERENCE_RE = /#{PEREFERENCE}/um
ENTITYVALUE = %Q{((?:"(?:[^%&"]|#{PEREFERENCE}|#{REFERENCE})*")|(?:'([^%&']|#{PEREFERENCE}|#{REFERENCE})*'))}
PEDEF = "(?:#{ENTITYVALUE}|#{EXTERNALID})"
ENTITYDEF = "(?:#{ENTITYVALUE}|(?:#{EXTERNALID}(#{NDATADECL})?))"
@@ -19,7 +20,7 @@ class Entity < Child
GEDECL = "<!ENTITY\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"
ENTITYDECL = /\s*(?:#{GEDECL})|(?:#{PEDECL})/um
- attr_reader :name, :external, :ref, :ndata, :pubid
+ attr_reader :name, :external, :ref, :ndata, :pubid, :value
# Create a new entity. Simple entities can be constructed by passing a
# name, value to the constructor; this creates a generic, plain entity
@@ -68,14 +69,14 @@ def Entity::matches? string
end
# Evaluates to the unnormalized value of this entity; that is, replacing
- # all entities -- both %ent; and &ent; entities. This differs from
- # +value()+ in that +value+ only replaces %ent; entities.
+ # &ent; entities.
def unnormalized
- document.record_entity_expansion unless document.nil?
- v = value()
- return nil if v.nil?
- @unnormalized = Text::unnormalize(v, parent)
- @unnormalized
+ document&.record_entity_expansion
+
+ return nil if @value.nil?
+
+ @unnormalized = Text::unnormalize(@value, parent,
+ entity_expansion_text_limit: document&.entity_expansion_text_limit)
end
#once :unnormalized
@@ -90,7 +91,7 @@ def normalized
# object itself is valid.)
#
# out::
- # An object implementing <TT><<<TT> to which the entity will be
+ # An object implementing <TT><<</TT> to which the entity will be
# output
# indent::
# *DEPRECATED* and ignored
@@ -121,36 +122,6 @@ def to_s
write rv
rv
end
-
- PEREFERENCE_RE = /#{PEREFERENCE}/um
- # Returns the value of this entity. At the moment, only internal entities
- # are processed. If the value contains internal references (IE,
- # %blah;), those are replaced with their values. IE, if the doctype
- # contains:
- # <!ENTITY % foo "bar">
- # <!ENTITY yada "nanoo %foo; nanoo>
- # then:
- # doctype.entity('yada').value #-> "nanoo bar nanoo"
- def value
- if @value
- matches = @value.scan(PEREFERENCE_RE)
- rv = @value.clone
- if @parent
- sum = 0
- matches.each do |entity_reference|
- entity_value = @parent.entity( entity_reference[0] )
- if sum + entity_value.bytesize > Security.entity_expansion_text_limit
- raise "entity expansion has grown too large"
- else
- sum += entity_value.bytesize
- end
- rv.gsub!( /%#{entity_reference.join};/um, entity_value )
- end
- end
- return rv
- end
- nil
- end
end
# This is a set of entity constants -- the ones defined in the XML
diff --git a/lib/rexml/formatters/default.rb b/lib/rexml/formatters/default.rb
index c375f1468b..811b2ff3d5 100644
--- a/lib/rexml/formatters/default.rb
+++ b/lib/rexml/formatters/default.rb
@@ -1,4 +1,5 @@
# frozen_string_literal: false
+
module REXML
module Formatters
class Default
@@ -101,11 +102,14 @@ def write_cdata( node, output )
end
def write_instruction( node, output )
- output << Instruction::START.sub(/\\/u, '')
+ output << Instruction::START
output << node.target
- output << ' '
- output << node.content
- output << Instruction::STOP.sub(/\\/u, '')
+ content = node.content
+ if content
+ output << ' '
+ output << content
+ end
+ output << Instruction::STOP
end
end
end
diff --git a/lib/rexml/formatters/pretty.rb b/lib/rexml/formatters/pretty.rb
index a80274bdad..a838d8357e 100644
--- a/lib/rexml/formatters/pretty.rb
+++ b/lib/rexml/formatters/pretty.rb
@@ -1,5 +1,5 @@
-# frozen_string_literal: false
-require 'rexml/formatters/default'
+# frozen_string_literal: true
+require_relative 'default'
module REXML
module Formatters
@@ -58,7 +58,7 @@ def write_element(node, output)
skip = false
if compact
if node.children.inject(true) {|s,c| s & c.kind_of?(Text)}
- string = ""
+ string = +""
old_level = @level
@level = 0
node.children.each { |child| write( child, string ) }
@@ -111,7 +111,7 @@ def write_document( node, output )
# itself, then we don't need a carriage return... which makes this
# logic more complex.
node.children.each { |child|
- next if child == node.children[-1] and child.instance_of?(Text)
+ next if child.instance_of?(Text)
unless child == node.children[0] or child.instance_of?(Text) or
(child == node.children[1] and !node.children[0].writethis)
output << "\n"
diff --git a/lib/rexml/formatters/transitive.rb b/lib/rexml/formatters/transitive.rb
index 81e67f3274..5ff51e10f3 100644
--- a/lib/rexml/formatters/transitive.rb
+++ b/lib/rexml/formatters/transitive.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require 'rexml/formatters/pretty'
+require_relative 'pretty'
module REXML
module Formatters
diff --git a/lib/rexml/functions.rb b/lib/rexml/functions.rb
index cd879fdd28..4c11461601 100644
--- a/lib/rexml/functions.rb
+++ b/lib/rexml/functions.rb
@@ -66,11 +66,11 @@ def Functions::count( node_set )
def Functions::id( object )
end
- # UNTESTED
- def Functions::local_name( node_set=nil )
- get_namespace( node_set ) do |node|
+ def Functions::local_name(node_set=nil)
+ get_namespace(node_set) do |node|
return node.local_name
end
+ ""
end
def Functions::namespace_uri( node_set=nil )
@@ -86,10 +86,14 @@ def Functions::name( node_set=nil )
# Helper method.
def Functions::get_namespace( node_set = nil )
if node_set == nil
- yield @@context[:node] if defined? @@context[:node].namespace
+ yield @@context[:node] if @@context[:node].respond_to?(:namespace)
else
if node_set.respond_to? :each
- node_set.each { |node| yield node if defined? node.namespace }
+ result = []
+ node_set.each do |node|
+ result << yield(node) if node.respond_to?(:namespace)
+ end
+ result
elsif node_set.respond_to? :namespace
yield node_set
end
@@ -131,22 +135,38 @@ def Functions::get_namespace( node_set = nil )
#
# An object of a type other than the four basic types is converted to a
# string in a way that is dependent on that type.
- def Functions::string( object=nil )
- #object = @context unless object
- if object.instance_of? Array
- string( object[0] )
- elsif defined? object.node_type
- if object.node_type == :attribute
+ def Functions::string( object=@@context[:node] )
+ if object.respond_to?(:node_type)
+ case object.node_type
+ when :attribute
object.value
- elsif object.node_type == :element || object.node_type == :document
+ when :element
string_value(object)
+ when :document
+ string_value(object.root)
+ when :processing_instruction
+ object.content
else
object.to_s
end
- elsif object.nil?
- return ""
else
- object.to_s
+ case object
+ when Array
+ string(object[0])
+ when Float
+ if object.nan?
+ "NaN"
+ else
+ integer = object.to_i
+ if object == integer
+ "%d" % integer
+ else
+ object.to_s
+ end
+ end
+ else
+ object.to_s
+ end
end
end
@@ -167,9 +187,12 @@ def Functions::string_value( o )
rv
end
- # UNTESTED
def Functions::concat( *objects )
- objects.join
+ concatenated = ""
+ objects.each do |object|
+ concatenated << string(object)
+ end
+ concatenated
end
# Fixed by Mike Stok
@@ -239,11 +262,10 @@ def Functions::string_length( string )
string(string).length
end
- # UNTESTED
def Functions::normalize_space( string=nil )
string = string(@@context[:node]) if string.nil?
if string.kind_of? Array
- string.collect{|x| string.to_s.strip.gsub(/\s+/um, ' ') if string}
+ string.collect{|x| x.to_s.strip.gsub(/\s+/um, ' ') if x}
else
string.to_s.strip.gsub(/\s+/um, ' ')
end
@@ -292,18 +314,23 @@ def Functions::translate( string, tr1, tr2 )
end
end
- # UNTESTED
- def Functions::boolean( object=nil )
- if object.kind_of? String
- if object =~ /\d+/u
- return object.to_f != 0
- else
- return object.size > 0
- end
- elsif object.kind_of? Array
- object = object.find{|x| x and true}
+ def Functions::boolean(object=@@context[:node])
+ case object
+ when true, false
+ object
+ when Float
+ return false if object.zero?
+ return false if object.nan?
+ true
+ when Numeric
+ not object.zero?
+ when String
+ not object.empty?
+ when Array
+ not object.empty?
+ else
+ object ? true : false
end
- return object ? true : false
end
# UNTESTED
@@ -357,25 +384,23 @@ def Functions::compare_language lang1, lang2
#
# an object of a type other than the four basic types is converted to a
# number in a way that is dependent on that type
- def Functions::number( object=nil )
- object = @@context[:node] unless object
+ def Functions::number(object=@@context[:node])
case object
when true
Float(1)
when false
Float(0)
when Array
- number(string( object ))
+ number(string(object))
when Numeric
object.to_f
else
- str = string( object )
- # If XPath ever gets scientific notation...
- #if str =~ /^\s*-?(\d*\.?\d+|\d+\.)([Ee]\d*)?\s*$/
- if str =~ /^\s*-?(\d*\.?\d+|\d+\.)\s*$/
- str.to_f
+ str = string(object)
+ case str.strip
+ when /\A\s*(-?(?:\d+(?:\.\d*)?|\.\d+))\s*\z/
+ $1.to_f
else
- (0.0 / 0.0)
+ Float::NAN
end
end
end
@@ -397,7 +422,7 @@ def Functions::round( number )
number = number(number)
begin
neg = number.negative?
- number = number.abs.round(half: :up)
+ number = number.abs.round
neg ? -number : number
rescue FloatDomainError
number
diff --git a/lib/rexml/instruction.rb b/lib/rexml/instruction.rb
index c4f65eefc1..318741f03b 100644
--- a/lib/rexml/instruction.rb
+++ b/lib/rexml/instruction.rb
@@ -1,13 +1,14 @@
# frozen_string_literal: false
-require "rexml/child"
-require "rexml/source"
+
+require_relative "child"
+require_relative "source"
module REXML
# Represents an XML Instruction; IE, <? ... ?>
# TODO: Add parent arg (3rd arg) to constructor
class Instruction < Child
- START = '<\?'
- STOP = '\?>'
+ START = "<?"
+ STOP = "?>"
# target is the "name" of the Instruction; IE, the "tag" in <?tag ...?>
# content is everything else.
@@ -17,20 +18,25 @@ class Instruction < Child
# @param target can be one of a number of things. If String, then
# the target of this instruction is set to this. If an Instruction,
# then the Instruction is shallowly cloned (target and content are
- # copied). If a Source, then the source is scanned and parsed for
- # an Instruction declaration.
+ # copied).
# @param content Must be either a String, or a Parent. Can only
# be a Parent if the target argument is a Source. Otherwise, this
# String is set as the content of this instruction.
def initialize(target, content=nil)
- if target.kind_of? String
+ case target
+ when String
super()
@target = target
@content = content
- elsif target.kind_of? Instruction
+ when Instruction
super(content)
@target = target.target
@content = target.content
+ else
+ message =
+ "processing instruction target must be String or REXML::Instruction: "
+ message << "<#{target.inspect}>"
+ raise ArgumentError, message
end
@content.strip! if @content
end
@@ -45,11 +51,13 @@ def clone
def write writer, indent=-1, transitive=false, ie_hack=false
Kernel.warn( "#{self.class.name}.write is deprecated", uplevel: 1)
indent(writer, indent)
- writer << START.sub(/\\/u, '')
+ writer << START
writer << @target
- writer << ' '
- writer << @content
- writer << STOP.sub(/\\/u, '')
+ if @content
+ writer << ' '
+ writer << @content
+ end
+ writer << STOP
end
# @return true if other is an Instruction, and the content and target
diff --git a/lib/rexml/light/node.rb b/lib/rexml/light/node.rb
index d58119a3a4..3dab885b0f 100644
--- a/lib/rexml/light/node.rb
+++ b/lib/rexml/light/node.rb
@@ -1,14 +1,6 @@
# frozen_string_literal: false
-require 'rexml/xmltokens'
-
-# [ :element, parent, name, attributes, children* ]
- # a = Node.new
- # a << "B" # => <a>B</a>
- # a.b # => <a>B<b/></a>
- # a.b[1] # => <a>B<b/><b/><a>
- # a.b[1]["x"] = "y" # => <a>B<b/><b x="y"/></a>
- # a.b[0].c # => <a>B<b><c/></b><b x="y"/></a>
- # a.b.c << "D" # => <a>B<b><c>D</c></b><b x="y"/></a>
+require_relative '../xmltokens'
+
module REXML
module Light
# Represents a tagged XML element. Elements are characterized by
diff --git a/lib/rexml/namespace.rb b/lib/rexml/namespace.rb
index 90ba7cc635..2e67252a51 100644
--- a/lib/rexml/namespace.rb
+++ b/lib/rexml/namespace.rb
@@ -1,5 +1,6 @@
-# frozen_string_literal: false
-require 'rexml/xmltokens'
+# frozen_string_literal: true
+
+require_relative 'xmltokens'
module REXML
# Adds named attributes to an object.
@@ -9,19 +10,33 @@ module Namespace
# The expanded name of the object, valid if name is set
attr_accessor :prefix
include XMLTokens
+ NAME_WITHOUT_NAMESPACE = /\A#{NCNAME_STR}\z/
NAMESPLIT = /^(?:(#{NCNAME_STR}):)?(#{NCNAME_STR})/u
# Sets the name and the expanded name
def name=( name )
@expanded_name = name
- name =~ NAMESPLIT
- if $1
- @prefix = $1
- else
+ if name.match?(NAME_WITHOUT_NAMESPACE)
@prefix = ""
@namespace = ""
+ @name = name
+ elsif name =~ NAMESPLIT
+ if $1
+ @prefix = $1
+ else
+ @prefix = ""
+ @namespace = ""
+ end
+ @name = $2
+ elsif name == ""
+ @prefix = nil
+ @namespace = nil
+ @name = nil
+ else
+ message = "name must be \#{PREFIX}:\#{LOCAL_NAME} or \#{LOCAL_NAME}: "
+ message += "<#{name.inspect}>"
+ raise ArgumentError, message
end
- @name = $2
end
# Compares names optionally WITH namespaces
diff --git a/lib/rexml/node.rb b/lib/rexml/node.rb
index 52337ade44..c771db70d1 100644
--- a/lib/rexml/node.rb
+++ b/lib/rexml/node.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: false
-require "rexml/parseexception"
-require "rexml/formatters/pretty"
-require "rexml/formatters/default"
+require_relative "parseexception"
+require_relative "formatters/pretty"
+require_relative "formatters/default"
module REXML
# Represents a node in the tree. Nodes are never encountered except as
@@ -52,10 +52,14 @@ def parent?
# Visit all subnodes of +self+ recursively
def each_recursive(&block) # :yields: node
- self.elements.each {|node|
- block.call(node)
- node.each_recursive(&block)
- }
+ stack = []
+ each { |child| stack.unshift child if child.node_type == :element }
+ until stack.empty?
+ child = stack.pop
+ yield child
+ n = stack.size
+ child.each { |grandchild| stack.insert n, grandchild if grandchild.node_type == :element }
+ end
end
# Find (and return) first subnode (recursively) for which the block
diff --git a/lib/rexml/output.rb b/lib/rexml/output.rb
index 96dfea570e..88a5fb378d 100644
--- a/lib/rexml/output.rb
+++ b/lib/rexml/output.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require 'rexml/encoding'
+require_relative 'encoding'
module REXML
class Output
diff --git a/lib/rexml/parent.rb b/lib/rexml/parent.rb
index 3bd0a96255..6a53b37a12 100644
--- a/lib/rexml/parent.rb
+++ b/lib/rexml/parent.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require "rexml/child"
+require_relative "child"
module REXML
# A parent has children, and has methods for accessing them. The Parent
diff --git a/lib/rexml/parseexception.rb b/lib/rexml/parseexception.rb
index 7b16cd1a41..e57d05fd2e 100644
--- a/lib/rexml/parseexception.rb
+++ b/lib/rexml/parseexception.rb
@@ -29,6 +29,7 @@ def to_s
err << "\nLine: #{line}\n"
err << "Position: #{position}\n"
err << "Last 80 unconsumed characters:\n"
+ err.force_encoding("ASCII-8BIT")
err << @source.buffer[0..80].force_encoding("ASCII-8BIT").gsub(/\n/, ' ')
end
diff --git a/lib/rexml/parsers/baseparser.rb b/lib/rexml/parsers/baseparser.rb
index e7ef695912..a567e045d6 100644
--- a/lib/rexml/parsers/baseparser.rb
+++ b/lib/rexml/parsers/baseparser.rb
@@ -1,14 +1,40 @@
-# frozen_string_literal: false
-
-require "strscan"
-
-require 'rexml/parseexception'
-require 'rexml/undefinednamespaceexception'
-require 'rexml/source'
+# frozen_string_literal: true
+require_relative '../parseexception'
+require_relative '../undefinednamespaceexception'
+require_relative '../security'
+require_relative '../source'
require 'set'
+require "strscan"
module REXML
module Parsers
+ unless [].respond_to?(:tally)
+ module EnumerableTally
+ refine Enumerable do
+ def tally
+ counts = {}
+ each do |item|
+ counts[item] ||= 0
+ counts[item] += 1
+ end
+ counts
+ end
+ end
+ end
+ using EnumerableTally
+ end
+
+ if StringScanner::Version < "3.0.8"
+ module StringScannerCaptures
+ refine StringScanner do
+ def captures
+ values_at(*(1...size))
+ end
+ end
+ end
+ using StringScannerCaptures
+ end
+
# = Using the Pull Parser
# <em>This API is experimental, and subject to change.</em>
# parser = PullParser.new( "<a>text<b att='val'/>txet</a>" )
@@ -61,7 +87,7 @@ class BaseParser
XMLDECL_START = /\A<\?xml\s/u;
XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>/um
INSTRUCTION_START = /\A<\?/u
- INSTRUCTION_PATTERN = /<\?(.*?)(\s+.*?)?\?>/um
+ INSTRUCTION_PATTERN = /<\?#{NAME}(\s+.*?)?\?>/um
TAG_MATCH = /\A<((?>#{QNAME_STR}))/um
CLOSE_MATCH = /\A\s*<\/(#{QNAME_STR})\s*>/um
@@ -98,7 +124,7 @@ class BaseParser
ENTITYDEF = "(?:#{ENTITYVALUE}|(?:#{EXTERNALID}(#{NDATADECL})?))"
PEDECL = "<!ENTITY\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>"
GEDECL = "<!ENTITY\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"
- ENTITYDECL = /\s*(?:#{GEDECL})|(?:#{PEDECL})/um
+ ENTITYDECL = /\s*(?:#{GEDECL})|\s*(?:#{PEDECL})/um
NOTATIONDECL_START = /\A\s*<!NOTATION/um
EXTERNAL_ID_PUBLIC = /\A\s*PUBLIC\s+#{PUBIDLITERAL}\s+#{SYSTEMLITERAL}\s*/um
@@ -114,16 +140,33 @@ class BaseParser
"apos" => [/'/, "'", "'", /'/]
}
-
- ######################################################################
- # These are patterns to identify common markup errors, to make the
- # error messages more informative.
- ######################################################################
- MISSING_ATTRIBUTE_QUOTES = /^<#{QNAME_STR}\s+#{QNAME_STR}\s*=\s*[^"']/um
+ module Private
+ PEREFERENCE_PATTERN = /#{PEREFERENCE}/um
+ TAG_PATTERN = /((?>#{QNAME_STR}))\s*/um
+ CLOSE_PATTERN = /(#{QNAME_STR})\s*>/um
+ ATTLISTDECL_END = /\s+#{NAME}(?:#{ATTDEF})*\s*>/um
+ NAME_PATTERN = /#{NAME}/um
+ GEDECL_PATTERN = "\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"
+ PEDECL_PATTERN = "\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>"
+ ENTITYDECL_PATTERN = /(?:#{GEDECL_PATTERN})|(?:#{PEDECL_PATTERN})/um
+ CARRIAGE_RETURN_NEWLINE_PATTERN = /\r\n?/
+ CHARACTER_REFERENCES = /�*((?:\d+)|(?:x[a-fA-F0-9]+));/
+ DEFAULT_ENTITIES_PATTERNS = {}
+ default_entities = ['gt', 'lt', 'quot', 'apos', 'amp']
+ default_entities.each do |term|
+ DEFAULT_ENTITIES_PATTERNS[term] = /&#{term};/
+ end
+ XML_PREFIXED_NAMESPACE = "http://www.w3.org/XML/1998/namespace"
+ end
+ private_constant :Private
def initialize( source )
self.stream = source
@listeners = []
+ @prefixes = Set.new
+ @entity_expansion_count = 0
+ @entity_expansion_limit = Security.entity_expansion_limit
+ @entity_expansion_text_limit = Security.entity_expansion_text_limit
end
def add_listener( listener )
@@ -131,15 +174,20 @@ def add_listener( listener )
end
attr_reader :source
+ attr_reader :entity_expansion_count
+ attr_writer :entity_expansion_limit
+ attr_writer :entity_expansion_text_limit
def stream=( source )
@source = SourceFactory.create_from( source )
@closed = nil
+ @have_root = false
@document_status = nil
@tags = []
@stack = []
@entities = []
- @nsstack = []
+ @namespaces = {"xml" => Private::XML_PREFIXED_NAMESPACE}
+ @namespaces_restore_stack = []
end
def position
@@ -189,6 +237,8 @@ def peek depth=0
# Returns the next event. This is a +PullEvent+ object.
def pull
+ @source.drop_parsed_content
+
pull_event.tap do |event|
@listeners.each do |listener|
listener.receive event
@@ -201,248 +251,280 @@ def pull_event
x, @closed = @closed, nil
return [ :end_element, x ]
end
- return [ :end_document ] if empty?
+ if empty?
+ if @document_status == :in_doctype
+ raise ParseException.new("Malformed DOCTYPE: unclosed", @source)
+ end
+ unless @tags.empty?
+ path = "/" + @tags.join("/")
+ raise ParseException.new("Missing end tag for '#{path}'", @source)
+ end
+ return [ :end_document ]
+ end
return @stack.shift if @stack.size > 0
#STDERR.puts @source.encoding
#STDERR.puts "BUFFER = #{@source.buffer.inspect}"
+
+ @source.ensure_buffer
if @document_status == nil
- word = @source.match( /\A((?:\s+)|(?:<[^>]*>))/um )
- word = word[1] unless word.nil?
- #STDERR.puts "WORD = #{word.inspect}"
- case word
- when COMMENT_START
- return [ :comment, @source.match( COMMENT_PATTERN, true )[1] ]
- when XMLDECL_START
- #STDERR.puts "XMLDECL"
- results = @source.match( XMLDECL_PATTERN, true )[1]
- version = VERSION.match( results )
- version = version[1] unless version.nil?
- encoding = ENCODING.match(results)
- encoding = encoding[1] unless encoding.nil?
- if need_source_encoding_update?(encoding)
- @source.encoding = encoding
- end
- if encoding.nil? and /\AUTF-16(?:BE|LE)\z/i =~ @source.encoding
- encoding = "UTF-16"
- end
- standalone = STANDALONE.match(results)
- standalone = standalone[1] unless standalone.nil?
- return [ :xmldecl, version, encoding, standalone ]
- when INSTRUCTION_START
- return [ :processing_instruction, *@source.match(INSTRUCTION_PATTERN, true)[1,2] ]
- when DOCTYPE_START
- base_error_message = "Malformed DOCTYPE"
- @source.match(DOCTYPE_START, true)
- @nsstack.unshift(curr_ns=Set.new)
- name = parse_name(base_error_message)
- if @source.match(/\A\s*\[/um, true)
- id = [nil, nil, nil]
- @document_status = :in_doctype
- elsif @source.match(/\A\s*>/um, true)
- id = [nil, nil, nil]
- @document_status = :after_doctype
- else
- id = parse_id(base_error_message,
- accept_external_id: true,
- accept_public_id: false)
- if id[0] == "SYSTEM"
- # For backward compatibility
- id[1], id[2] = id[2], nil
+ start_position = @source.position
+ if @source.match("<?", true)
+ return process_instruction
+ elsif @source.match("<!", true)
+ if @source.match("--", true)
+ md = @source.match(/(.*?)-->/um, true)
+ if md.nil?
+ raise REXML::ParseException.new("Unclosed comment", @source)
+ end
+ if /--|-\z/.match?(md[1])
+ raise REXML::ParseException.new("Malformed comment", @source)
end
- if @source.match(/\A\s*\[/um, true)
- @document_status = :in_doctype
- elsif @source.match(/\A\s*>/um, true)
+ return [ :comment, md[1] ]
+ elsif @source.match("DOCTYPE", true)
+ base_error_message = "Malformed DOCTYPE"
+ unless @source.match(/\s+/um, true)
+ if @source.match(">")
+ message = "#{base_error_message}: name is missing"
+ else
+ message = "#{base_error_message}: invalid name"
+ end
+ @source.position = start_position
+ raise REXML::ParseException.new(message, @source)
+ end
+ name = parse_name(base_error_message)
+ if @source.match(/\s*\[/um, true)
+ id = [nil, nil, nil]
+ @document_status = :in_doctype
+ elsif @source.match(/\s*>/um, true)
+ id = [nil, nil, nil]
@document_status = :after_doctype
+ @source.ensure_buffer
else
- message = "#{base_error_message}: garbage after external ID"
- raise REXML::ParseException.new(message, @source)
+ id = parse_id(base_error_message,
+ accept_external_id: true,
+ accept_public_id: false)
+ if id[0] == "SYSTEM"
+ # For backward compatibility
+ id[1], id[2] = id[2], nil
+ end
+ if @source.match(/\s*\[/um, true)
+ @document_status = :in_doctype
+ elsif @source.match(/\s*>/um, true)
+ @document_status = :after_doctype
+ @source.ensure_buffer
+ else
+ message = "#{base_error_message}: garbage after external ID"
+ raise REXML::ParseException.new(message, @source)
+ end
end
- end
- args = [:start_doctype, name, *id]
- if @document_status == :after_doctype
- @source.match(/\A\s*/um, true)
- @stack << [ :end_doctype ]
- end
- return args
- when /\A\s+/
- else
- @document_status = :after_doctype
- if @source.encoding == "UTF-8"
- @source.buffer.force_encoding(::Encoding::UTF_8)
+ args = [:start_doctype, name, *id]
+ if @document_status == :after_doctype
+ @source.match(/\s*/um, true)
+ @stack << [ :end_doctype ]
+ end
+ return args
+ else
+ message = "Invalid XML"
+ raise REXML::ParseException.new(message, @source)
end
end
end
if @document_status == :in_doctype
- md = @source.match(/\A\s*(.*?>)/um)
- case md[1]
- when SYSTEMENTITY
- match = @source.match( SYSTEMENTITY, true )[1]
- return [ :externalentity, match ]
-
- when ELEMENTDECL_START
- return [ :elementdecl, @source.match( ELEMENTDECL_PATTERN, true )[1] ]
-
- when ENTITY_START
- match = @source.match( ENTITYDECL, true ).to_a.compact
- match[0] = :entitydecl
- ref = false
- if match[1] == '%'
- ref = true
- match.delete_at 1
- end
- # Now we have to sort out what kind of entity reference this is
- if match[2] == 'SYSTEM'
- # External reference
- match[3] = match[3][1..-2] # PUBID
- match.delete_at(4) if match.size > 4 # Chop out NDATA decl
- # match is [ :entity, name, SYSTEM, pubid(, ndata)? ]
- elsif match[2] == 'PUBLIC'
- # External reference
- match[3] = match[3][1..-2] # PUBID
- match[4] = match[4][1..-2] # HREF
- match.delete_at(5) if match.size > 5 # Chop out NDATA decl
- # match is [ :entity, name, PUBLIC, pubid, href(, ndata)? ]
- else
- match[2] = match[2][1..-2]
- match.pop if match.size == 4
- # match is [ :entity, name, value ]
- end
- match << '%' if ref
- return match
- when ATTLISTDECL_START
- md = @source.match( ATTLISTDECL_PATTERN, true )
- raise REXML::ParseException.new( "Bad ATTLIST declaration!", @source ) if md.nil?
- element = md[1]
- contents = md[0]
-
- pairs = {}
- values = md[0].scan( ATTDEF_RE )
- values.each do |attdef|
- unless attdef[3] == "#IMPLIED"
- attdef.compact!
- val = attdef[3]
- val = attdef[4] if val == "#FIXED "
- pairs[attdef[0]] = val
- if attdef[0] =~ /^xmlns:(.*)/
- @nsstack[0] << $1
- end
+ @source.match(/\s*/um, true) # skip spaces
+ start_position = @source.position
+ if @source.match("<!", true)
+ if @source.match("ELEMENT", true)
+ md = @source.match(/(.*?)>/um, true)
+ raise REXML::ParseException.new( "Bad ELEMENT declaration!", @source ) if md.nil?
+ return [ :elementdecl, "<!ELEMENT" + md[1] ]
+ elsif @source.match("ENTITY", true)
+ match_data = @source.match(Private::ENTITYDECL_PATTERN, true)
+ unless match_data
+ raise REXML::ParseException.new("Malformed entity declaration", @source)
end
- end
- return [ :attlistdecl, element, pairs, contents ]
- when NOTATIONDECL_START
- base_error_message = "Malformed notation declaration"
- unless @source.match(/\A\s*<!NOTATION\s+/um, true)
- if @source.match(/\A\s*<!NOTATION\s*>/um)
- message = "#{base_error_message}: name is missing"
+ match = [:entitydecl, *match_data.captures.compact]
+ ref = false
+ if match[1] == '%'
+ ref = true
+ match.delete_at 1
+ end
+ # Now we have to sort out what kind of entity reference this is
+ if match[2] == 'SYSTEM'
+ # External reference
+ match[3] = match[3][1..-2] # PUBID
+ match.delete_at(4) if match.size > 4 # Chop out NDATA decl
+ # match is [ :entity, name, SYSTEM, pubid(, ndata)? ]
+ elsif match[2] == 'PUBLIC'
+ # External reference
+ match[3] = match[3][1..-2] # PUBID
+ match[4] = match[4][1..-2] # HREF
+ match.delete_at(5) if match.size > 5 # Chop out NDATA decl
+ # match is [ :entity, name, PUBLIC, pubid, href(, ndata)? ]
+ elsif Private::PEREFERENCE_PATTERN.match?(match[2])
+ raise REXML::ParseException.new("Parameter entity references forbidden in internal subset: #{match[2]}", @source)
else
- message = "#{base_error_message}: invalid declaration name"
+ match[2] = match[2][1..-2]
+ match.pop if match.size == 4
+ # match is [ :entity, name, value ]
end
- raise REXML::ParseException.new(message, @source)
- end
- name = parse_name(base_error_message)
- id = parse_id(base_error_message,
- accept_external_id: true,
- accept_public_id: true)
- unless @source.match(/\A\s*>/um, true)
- message = "#{base_error_message}: garbage before end >"
- raise REXML::ParseException.new(message, @source)
+ match << '%' if ref
+ return match
+ elsif @source.match("ATTLIST", true)
+ md = @source.match(Private::ATTLISTDECL_END, true)
+ raise REXML::ParseException.new( "Bad ATTLIST declaration!", @source ) if md.nil?
+ element = md[1]
+ contents = md[0]
+
+ pairs = {}
+ values = md[0].strip.scan( ATTDEF_RE )
+ values.each do |attdef|
+ unless attdef[3] == "#IMPLIED"
+ attdef.compact!
+ val = attdef[3]
+ val = attdef[4] if val == "#FIXED "
+ pairs[attdef[0]] = val
+ if attdef[0] =~ /^xmlns:(.*)/
+ @namespaces[$1] = val
+ end
+ end
+ end
+ return [ :attlistdecl, element, pairs, contents ]
+ elsif @source.match("NOTATION", true)
+ base_error_message = "Malformed notation declaration"
+ unless @source.match(/\s+/um, true)
+ if @source.match(">")
+ message = "#{base_error_message}: name is missing"
+ else
+ message = "#{base_error_message}: invalid name"
+ end
+ @source.position = start_position
+ raise REXML::ParseException.new(message, @source)
+ end
+ name = parse_name(base_error_message)
+ id = parse_id(base_error_message,
+ accept_external_id: true,
+ accept_public_id: true)
+ unless @source.match(/\s*>/um, true)
+ message = "#{base_error_message}: garbage before end >"
+ raise REXML::ParseException.new(message, @source)
+ end
+ return [:notationdecl, name, *id]
+ elsif md = @source.match(/--(.*?)-->/um, true)
+ case md[1]
+ when /--/, /-\z/
+ raise REXML::ParseException.new("Malformed comment", @source)
+ end
+ return [ :comment, md[1] ] if md
end
- return [:notationdecl, name, *id]
- when DOCTYPE_END
+ elsif match = @source.match(/(%.*?;)\s*/um, true)
+ return [ :externalentity, match[1] ]
+ elsif @source.match(/\]\s*>/um, true)
@document_status = :after_doctype
- @source.match( DOCTYPE_END, true )
return [ :end_doctype ]
end
+ if @document_status == :in_doctype
+ raise ParseException.new("Malformed DOCTYPE: invalid declaration", @source)
+ end
end
if @document_status == :after_doctype
- @source.match(/\A\s*/um, true)
+ @source.match(/\s*/um, true)
end
begin
- @source.read if @source.buffer.size<2
- if @source.buffer[0] == ?<
- if @source.buffer[1] == ?/
- @nsstack.shift
+ start_position = @source.position
+ if @source.match("<", true)
+ # :text's read_until may remain only "<" in buffer. In the
+ # case, buffer is empty here. So we need to fill buffer
+ # here explicitly.
+ @source.ensure_buffer
+ if @source.match("/", true)
+ @namespaces_restore_stack.pop
last_tag = @tags.pop
- #md = @source.match_to_consume( '>', CLOSE_MATCH)
- md = @source.match( CLOSE_MATCH, true )
+ md = @source.match(Private::CLOSE_PATTERN, true)
if md and !last_tag
message = "Unexpected top-level end tag (got '#{md[1]}')"
raise REXML::ParseException.new(message, @source)
end
if md.nil? or last_tag != md[1]
message = "Missing end tag for '#{last_tag}'"
- message << " (got '#{md[1]}')" if md
+ message += " (got '#{md[1]}')" if md
+ @source.position = start_position if md.nil?
raise REXML::ParseException.new(message, @source)
end
return [ :end_element, last_tag ]
- elsif @source.buffer[1] == ?!
- md = @source.match(/\A(\s*[^>]*>)/um)
+ elsif @source.match("!", true)
+ md = @source.match(/([^>]*>)/um)
#STDERR.puts "SOURCE BUFFER = #{source.buffer}, #{source.buffer.size}"
raise REXML::ParseException.new("Malformed node", @source) unless md
- if md[0][2] == ?-
- md = @source.match( COMMENT_PATTERN, true )
+ if md[0][0] == ?-
+ md = @source.match(/--(.*?)-->/um, true)
- case md[1]
- when /--/, /-\z/
+ if md.nil? || /--|-\z/.match?(md[1])
raise REXML::ParseException.new("Malformed comment", @source)
end
- return [ :comment, md[1] ] if md
+ return [ :comment, md[1] ]
else
- md = @source.match( CDATA_PATTERN, true )
+ md = @source.match(/\[CDATA\[(.*?)\]\]>/um, true)
return [ :cdata, md[1] ] if md
end
raise REXML::ParseException.new( "Declarations can only occur "+
"in the doctype declaration.", @source)
- elsif @source.buffer[1] == ??
- md = @source.match( INSTRUCTION_PATTERN, true )
- return [ :processing_instruction, md[1], md[2] ] if md
- raise REXML::ParseException.new( "Bad instruction declaration",
- @source)
+ elsif @source.match("?", true)
+ return process_instruction
else
# Get the next tag
- md = @source.match(TAG_MATCH, true)
+ md = @source.match(Private::TAG_PATTERN, true)
unless md
- # Check for missing attribute quotes
- raise REXML::ParseException.new("missing attribute quote", @source) if @source.match(MISSING_ATTRIBUTE_QUOTES )
+ @source.position = start_position
raise REXML::ParseException.new("malformed XML: missing tag start", @source)
end
+ tag = md[1]
@document_status = :in_element
- prefixes = Set.new
- prefixes << md[2] if md[2]
- @nsstack.unshift(curr_ns=Set.new)
- attributes, closed = parse_attributes(prefixes, curr_ns)
+ @prefixes.clear
+ @prefixes << md[2] if md[2]
+ push_namespaces_restore
+ attributes, closed = parse_attributes(@prefixes)
# Verify that all of the prefixes have been defined
- for prefix in prefixes
- unless @nsstack.find{|k| k.member?(prefix)}
+ for prefix in @prefixes
+ unless @namespaces.key?(prefix)
raise UndefinedNamespaceException.new(prefix,@source,self)
end
end
if closed
- @closed = md[1]
- @nsstack.shift
+ @closed = tag
+ pop_namespaces_restore
else
- @tags.push( md[1] )
+ if @tags.empty? and @have_root
+ raise ParseException.new("Malformed XML: Extra tag at the end of the document (got '<#{tag}')", @source)
+ end
+ @tags.push( tag )
end
- return [ :start_element, md[1], attributes ]
+ @have_root = true
+ return [ :start_element, tag, attributes ]
end
else
- md = @source.match( TEXT_PATTERN, true )
- if md[0].length == 0
- @source.match( /(\s+)/, true )
+ text = @source.read_until("<")
+ if text.chomp!("<")
+ @source.position -= "<".bytesize
end
- #STDERR.puts "GOT #{md[1].inspect}" unless md[0].length == 0
- #return [ :text, "" ] if md[0].length == 0
- # unnormalized = Text::unnormalize( md[1], self )
- # return PullEvent.new( :text, md[1], unnormalized )
- return [ :text, md[1] ]
+ if @tags.empty?
+ unless /\A\s*\z/.match?(text)
+ if @have_root
+ raise ParseException.new("Malformed XML: Extra content at the end of the document (got '#{text}')", @source)
+ else
+ raise ParseException.new("Malformed XML: Content at the start of the document (got '#{text}')", @source)
+ end
+ end
+ return pull_event if @have_root
+ end
+ return [ :text, text ]
end
rescue REXML::UndefinedNamespaceException
raise
rescue REXML::ParseException
raise
- rescue Exception, NameError => error
+ rescue => error
raise REXML::ParseException.new( "Exception parsing",
@source, self, (error ? error : $!) )
end
@@ -451,13 +533,13 @@ def pull_event
private :pull_event
def entity( reference, entities )
- value = nil
- value = entities[ reference ] if entities
- if not value
- value = DEFAULT_ENTITIES[ reference ]
- value = value[2] if value
- end
- unnormalize( value, entities ) if value
+ return unless entities
+
+ value = entities[ reference ]
+ return if value.nil?
+
+ record_entity_expansion
+ unnormalize( value, entities )
end
# Escapes all possible entities
@@ -478,35 +560,83 @@ def normalize( input, entities=nil, entity_filter=nil )
# Unescapes all possible entities
def unnormalize( string, entities=nil, filter=nil )
- rv = string.clone
- rv.gsub!( /\r\n?/, "\n" )
+ if string.include?("\r")
+ rv = string.gsub( Private::CARRIAGE_RETURN_NEWLINE_PATTERN, "\n" )
+ else
+ rv = string.dup
+ end
matches = rv.scan( REFERENCE_RE )
return rv if matches.size == 0
- rv.gsub!( /�*((?:\d+)|(?:x[a-fA-F0-9]+));/ ) {
+ rv.gsub!( Private::CHARACTER_REFERENCES ) {
m=$1
m = "0#{m}" if m[0] == ?x
[Integer(m)].pack('U*')
}
matches.collect!{|x|x[0]}.compact!
+ if filter
+ matches.reject! do |entity_reference|
+ filter.include?(entity_reference)
+ end
+ end
if matches.size > 0
- matches.each do |entity_reference|
- unless filter and filter.include?(entity_reference)
- entity_value = entity( entity_reference, entities )
- if entity_value
- re = /&#{entity_reference};/
- rv.gsub!( re, entity_value )
- else
- er = DEFAULT_ENTITIES[entity_reference]
- rv.gsub!( er[0], er[2] ) if er
+ matches.tally.each do |entity_reference, n|
+ entity_expansion_count_before = @entity_expansion_count
+ entity_value = entity( entity_reference, entities )
+ if entity_value
+ if n > 1
+ entity_expansion_count_delta =
+ @entity_expansion_count - entity_expansion_count_before
+ record_entity_expansion(entity_expansion_count_delta * (n - 1))
end
+ re = Private::DEFAULT_ENTITIES_PATTERNS[entity_reference] || /&#{entity_reference};/
+ rv.gsub!( re, entity_value )
+ if rv.bytesize > @entity_expansion_text_limit
+ raise "entity expansion has grown too large"
+ end
+ else
+ er = DEFAULT_ENTITIES[entity_reference]
+ rv.gsub!( er[0], er[2] ) if er
end
end
- rv.gsub!( /&/, '&' )
+ rv.gsub!( Private::DEFAULT_ENTITIES_PATTERNS['amp'], '&' )
end
rv
end
private
+ def add_namespace(prefix, uri)
+ @namespaces_restore_stack.last[prefix] = @namespaces[prefix]
+ if uri.nil?
+ @namespaces.delete(prefix)
+ else
+ @namespaces[prefix] = uri
+ end
+ end
+
+ def push_namespaces_restore
+ namespaces_restore = {}
+ @namespaces_restore_stack.push(namespaces_restore)
+ namespaces_restore
+ end
+
+ def pop_namespaces_restore
+ namespaces_restore = @namespaces_restore_stack.pop
+ namespaces_restore.each do |prefix, uri|
+ if uri.nil?
+ @namespaces.delete(prefix)
+ else
+ @namespaces[prefix] = uri
+ end
+ end
+ end
+
+ def record_entity_expansion(delta=1)
+ @entity_expansion_count += delta
+ if @entity_expansion_count > @entity_expansion_limit
+ raise "number of entity expansions exceeded, processing aborted."
+ end
+ end
+
def need_source_encoding_update?(xml_declaration_encoding)
return false if xml_declaration_encoding.nil?
return false if /\AUTF-16\z/i =~ xml_declaration_encoding
@@ -514,16 +644,16 @@ def need_source_encoding_update?(xml_declaration_encoding)
end
def parse_name(base_error_message)
- md = @source.match(/\A\s*#{NAME}/um, true)
+ md = @source.match(Private::NAME_PATTERN, true)
unless md
- if @source.match(/\A\s*\S/um)
+ if @source.match(/\S/um)
message = "#{base_error_message}: invalid name"
else
message = "#{base_error_message}: name is missing"
end
raise REXML::ParseException.new(message, @source)
end
- md[1]
+ md[0]
end
def parse_id(base_error_message,
@@ -592,88 +722,115 @@ def parse_id_invalid_details(accept_external_id:,
end
end
- def parse_attributes(prefixes, curr_ns)
- attributes = {}
- closed = false
- match_data = @source.match(/^(.*?)(\/)?>/um, true)
- if match_data.nil?
- message = "Start tag isn't ended"
- raise REXML::ParseException.new(message, @source)
+ def process_instruction
+ name = parse_name("Malformed XML: Invalid processing instruction node")
+ if @source.match(/\s+/um, true)
+ match_data = @source.match(/(.*?)\?>/um, true)
+ unless match_data
+ raise ParseException.new("Malformed XML: Unclosed processing instruction", @source)
+ end
+ content = match_data[1]
+ else
+ content = nil
+ unless @source.match("?>", true)
+ raise ParseException.new("Malformed XML: Unclosed processing instruction", @source)
+ end
end
-
- raw_attributes = match_data[1]
- closed = !match_data[2].nil?
- return attributes, closed if raw_attributes.nil?
- return attributes, closed if raw_attributes.empty?
-
- scanner = StringScanner.new(raw_attributes)
- until scanner.eos?
- if scanner.scan(/\s+/)
- break if scanner.eos?
+ if name == "xml"
+ if @document_status
+ raise ParseException.new("Malformed XML: XML declaration is not at the start", @source)
+ end
+ version = VERSION.match(content)
+ version = version[1] unless version.nil?
+ encoding = ENCODING.match(content)
+ encoding = encoding[1] unless encoding.nil?
+ if need_source_encoding_update?(encoding)
+ @source.encoding = encoding
+ end
+ if encoding.nil? and /\AUTF-16(?:BE|LE)\z/i =~ @source.encoding
+ encoding = "UTF-16"
end
+ standalone = STANDALONE.match(content)
+ standalone = standalone[1] unless standalone.nil?
+ return [ :xmldecl, version, encoding, standalone ]
+ end
+ [:processing_instruction, name, content]
+ end
- pos = scanner.pos
- loop do
- break if scanner.scan(ATTRIBUTE_PATTERN)
- unless scanner.scan(QNAME)
- message = "Invalid attribute name: <#{scanner.rest}>"
- raise REXML::ParseException.new(message, @source)
- end
- name = scanner[0]
- unless scanner.scan(/\s*=\s*/um)
+ def parse_attributes(prefixes)
+ attributes = {}
+ expanded_names = {}
+ closed = false
+ while true
+ if @source.match(">", true)
+ return attributes, closed
+ elsif @source.match("/>", true)
+ closed = true
+ return attributes, closed
+ elsif match = @source.match(QNAME, true)
+ name = match[1]
+ prefix = match[2]
+ local_part = match[3]
+
+ unless @source.match(/\s*=\s*/um, true)
message = "Missing attribute equal: <#{name}>"
raise REXML::ParseException.new(message, @source)
end
- quote = scanner.scan(/['"]/)
- unless quote
+ unless match = @source.match(/(['"])/, true)
message = "Missing attribute value start quote: <#{name}>"
raise REXML::ParseException.new(message, @source)
end
- unless scanner.scan(/.*#{Regexp.escape(quote)}/um)
- match_data = @source.match(/^(.*?)(\/)?>/um, true)
- if match_data
- scanner << "/" if closed
- scanner << ">"
- scanner << match_data[1]
- scanner.pos = pos
- closed = !match_data[2].nil?
- next
- end
- message =
- "Missing attribute value end quote: <#{name}>: <#{quote}>"
+ quote = match[1]
+ start_position = @source.position
+ value = @source.read_until(quote)
+ unless value.chomp!(quote)
+ @source.position = start_position
+ message = "Missing attribute value end quote: <#{name}>: <#{quote}>"
raise REXML::ParseException.new(message, @source)
end
- end
- name = scanner[1]
- prefix = scanner[2]
- local_part = scanner[3]
- # quote = scanner[4]
- value = scanner[5]
- if prefix == "xmlns"
- if local_part == "xml"
- if value != "http://www.w3.org/XML/1998/namespace"
- msg = "The 'xml' prefix must not be bound to any other namespace "+
+ @source.match(/\s*/um, true)
+ if prefix == "xmlns"
+ if local_part == "xml"
+ if value != Private::XML_PREFIXED_NAMESPACE
+ msg = "The 'xml' prefix must not be bound to any other namespace "+
+ "(http://www.w3.org/TR/REC-xml-names/#ns-decl)"
+ raise REXML::ParseException.new( msg, @source, self )
+ end
+ elsif local_part == "xmlns"
+ msg = "The 'xmlns' prefix must not be declared "+
"(http://www.w3.org/TR/REC-xml-names/#ns-decl)"
- raise REXML::ParseException.new( msg, @source, self )
+ raise REXML::ParseException.new( msg, @source, self)
end
- elsif local_part == "xmlns"
- msg = "The 'xmlns' prefix must not be declared "+
- "(http://www.w3.org/TR/REC-xml-names/#ns-decl)"
- raise REXML::ParseException.new( msg, @source, self)
+ add_namespace(local_part, value)
+ elsif prefix
+ prefixes << prefix unless prefix == "xml"
end
- curr_ns << local_part
- elsif prefix
- prefixes << prefix unless prefix == "xml"
- end
- if attributes.has_key?(name)
- msg = "Duplicate attribute #{name.inspect}"
- raise REXML::ParseException.new(msg, @source, self)
- end
+ if attributes[name]
+ msg = "Duplicate attribute #{name.inspect}"
+ raise REXML::ParseException.new(msg, @source, self)
+ end
- attributes[name] = value
+ unless prefix == "xmlns"
+ uri = @namespaces[prefix]
+ expanded_name = [uri, local_part]
+ existing_prefix = expanded_names[expanded_name]
+ if existing_prefix
+ message = "Namespace conflict in adding attribute " +
+ "\"#{local_part}\": " +
+ "Prefix \"#{existing_prefix}\" = \"#{uri}\" and " +
+ "prefix \"#{prefix}\" = \"#{uri}\""
+ raise REXML::ParseException.new(message, @source, self)
+ end
+ expanded_names[expanded_name] = prefix
+ end
+
+ attributes[name] = value
+ else
+ message = "Invalid attribute name: <#{@source.buffer.split(%r{[/>\s]}).first}>"
+ raise REXML::ParseException.new(message, @source)
+ end
end
- return attributes, closed
end
end
end
diff --git a/lib/rexml/parsers/lightparser.rb b/lib/rexml/parsers/lightparser.rb
index f0601ae51b..bdc08276a9 100644
--- a/lib/rexml/parsers/lightparser.rb
+++ b/lib/rexml/parsers/lightparser.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: false
-require 'rexml/parsers/streamparser'
-require 'rexml/parsers/baseparser'
-require 'rexml/light/node'
+require_relative 'streamparser'
+require_relative 'baseparser'
+require_relative '../light/node'
module REXML
module Parsers
diff --git a/lib/rexml/parsers/pullparser.rb b/lib/rexml/parsers/pullparser.rb
index 8c49217553..a331eff524 100644
--- a/lib/rexml/parsers/pullparser.rb
+++ b/lib/rexml/parsers/pullparser.rb
@@ -1,9 +1,9 @@
# frozen_string_literal: false
require 'forwardable'
-require 'rexml/parseexception'
-require 'rexml/parsers/baseparser'
-require 'rexml/xmltokens'
+require_relative '../parseexception'
+require_relative 'baseparser'
+require_relative '../xmltokens'
module REXML
module Parsers
@@ -47,6 +47,18 @@ def add_listener( listener )
@listeners << listener
end
+ def entity_expansion_count
+ @parser.entity_expansion_count
+ end
+
+ def entity_expansion_limit=( limit )
+ @parser.entity_expansion_limit = limit
+ end
+
+ def entity_expansion_text_limit=( limit )
+ @parser.entity_expansion_text_limit = limit
+ end
+
def each
while has_next?
yield self.pull
diff --git a/lib/rexml/parsers/sax2parser.rb b/lib/rexml/parsers/sax2parser.rb
index 1386f69c83..a51477de21 100644
--- a/lib/rexml/parsers/sax2parser.rb
+++ b/lib/rexml/parsers/sax2parser.rb
@@ -1,8 +1,8 @@
# frozen_string_literal: false
-require 'rexml/parsers/baseparser'
-require 'rexml/parseexception'
-require 'rexml/namespace'
-require 'rexml/text'
+require_relative 'baseparser'
+require_relative '../parseexception'
+require_relative '../namespace'
+require_relative '../text'
module REXML
module Parsers
@@ -22,6 +22,18 @@ def source
@parser.source
end
+ def entity_expansion_count
+ @parser.entity_expansion_count
+ end
+
+ def entity_expansion_limit=( limit )
+ @parser.entity_expansion_limit = limit
+ end
+
+ def entity_expansion_text_limit=( limit )
+ @parser.entity_expansion_text_limit = limit
+ end
+
def add_listener( listener )
@parser.add_listener( listener )
end
@@ -157,25 +169,8 @@ def parse
end
end
when :text
- #normalized = @parser.normalize( event[1] )
- #handle( :characters, normalized )
- copy = event[1].clone
-
- esub = proc { |match|
- if @entities.has_key?($1)
- @entities[$1].gsub(Text::REFERENCE, &esub)
- else
- match
- end
- }
-
- copy.gsub!( Text::REFERENCE, &esub )
- copy.gsub!( Text::NUMERICENTITY ) {|m|
- m=$1
- m = "0#{m}" if m[0] == ?x
- [Integer(m)].pack('U*')
- }
- handle( :characters, copy )
+ unnormalized = @parser.unnormalize( event[1], @entities )
+ handle( :characters, unnormalized )
when :entitydecl
handle_entitydecl( event )
when :processing_instruction, :comment, :attlistdecl,
@@ -264,6 +259,8 @@ def add( pair )
end
def get_namespace( prefix )
+ return nil if @namespace_stack.empty?
+
uris = (@namespace_stack.find_all { |ns| not ns[prefix].nil? }) ||
(@namespace_stack.find { |ns| not ns[nil].nil? })
uris[-1][prefix] unless uris.nil? or 0 == uris.size
diff --git a/lib/rexml/parsers/streamparser.rb b/lib/rexml/parsers/streamparser.rb
index f6a8bfa802..6c64d97893 100644
--- a/lib/rexml/parsers/streamparser.rb
+++ b/lib/rexml/parsers/streamparser.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require "rexml/parsers/baseparser"
+require_relative "baseparser"
module REXML
module Parsers
@@ -7,37 +7,42 @@ class StreamParser
def initialize source, listener
@listener = listener
@parser = BaseParser.new( source )
- @tag_stack = []
+ @entities = {}
end
def add_listener( listener )
@parser.add_listener( listener )
end
+ def entity_expansion_count
+ @parser.entity_expansion_count
+ end
+
+ def entity_expansion_limit=( limit )
+ @parser.entity_expansion_limit = limit
+ end
+
+ def entity_expansion_text_limit=( limit )
+ @parser.entity_expansion_text_limit = limit
+ end
+
def parse
# entity string
while true
event = @parser.pull
case event[0]
when :end_document
- unless @tag_stack.empty?
- tag_path = "/" + @tag_stack.join("/")
- raise ParseException.new("Missing end tag for '#{tag_path}'",
- @parser.source)
- end
return
when :start_element
- @tag_stack << event[1]
attrs = event[2].each do |n, v|
event[2][n] = @parser.unnormalize( v )
end
@listener.tag_start( event[1], attrs )
when :end_element
@listener.tag_end( event[1] )
- @tag_stack.pop
when :text
- normalized = @parser.unnormalize( event[1] )
- @listener.text( normalized )
+ unnormalized = @parser.unnormalize( event[1], @entities )
+ @listener.text( unnormalized )
when :processing_instruction
@listener.instruction( *event[1,2] )
when :start_doctype
@@ -48,6 +53,7 @@ def parse
when :comment, :attlistdecl, :cdata, :xmldecl, :elementdecl
@listener.send( event[0].to_s, *event[1..-1] )
when :entitydecl, :notationdecl
+ @entities[ event[1] ] = event[2] if event.size == 3
@listener.send( event[0].to_s, event[1..-1] )
when :externalentity
entity_reference = event[1]
diff --git a/lib/rexml/parsers/treeparser.rb b/lib/rexml/parsers/treeparser.rb
index fc0993c72a..4565a406cb 100644
--- a/lib/rexml/parsers/treeparser.rb
+++ b/lib/rexml/parsers/treeparser.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: false
-require 'rexml/validation/validationexception'
-require 'rexml/undefinednamespaceexception'
+require_relative '../validation/validationexception'
+require_relative '../undefinednamespaceexception'
module REXML
module Parsers
@@ -15,8 +15,6 @@ def add_listener( listener )
end
def parse
- tag_stack = []
- in_doctype = false
entities = nil
begin
while true
@@ -24,32 +22,24 @@ def parse
#STDERR.puts "TREEPARSER GOT #{event.inspect}"
case event[0]
when :end_document
- unless tag_stack.empty?
- raise ParseException.new("No close tag for #{@build_context.xpath}",
- @parser.source, @parser)
- end
return
when :start_element
- tag_stack.push(event[1])
el = @build_context = @build_context.add_element( event[1] )
event[2].each do |key, value|
el.attributes[key]=Attribute.new(key,value,self)
end
when :end_element
- tag_stack.pop
@build_context = @build_context.parent
when :text
- if not in_doctype
- if @build_context[-1].instance_of? Text
- @build_context[-1] << event[1]
- else
- @build_context.add(
- Text.new(event[1], @build_context.whitespace, nil, true)
- ) unless (
- @build_context.ignore_whitespace_nodes and
- event[1].strip.size==0
- )
- end
+ if @build_context[-1].instance_of? Text
+ @build_context[-1] << event[1]
+ else
+ @build_context.add(
+ Text.new(event[1], @build_context.whitespace, nil, true)
+ ) unless (
+ @build_context.ignore_whitespace_nodes and
+ event[1].strip.size==0
+ )
end
when :comment
c = Comment.new( event[1] )
@@ -60,14 +50,12 @@ def parse
when :processing_instruction
@build_context.add( Instruction.new( event[1], event[2] ) )
when :end_doctype
- in_doctype = false
entities.each { |k,v| entities[k] = @build_context.entities[k].value }
@build_context = @build_context.parent
when :start_doctype
doctype = DocType.new( event[1..-1], @build_context )
@build_context = doctype
entities = {}
- in_doctype = true
when :attlistdecl
n = AttlistDecl.new( event[1..-1] )
@build_context.add( n )
diff --git a/lib/rexml/parsers/ultralightparser.rb b/lib/rexml/parsers/ultralightparser.rb
index 6571d119bd..e0029f43da 100644
--- a/lib/rexml/parsers/ultralightparser.rb
+++ b/lib/rexml/parsers/ultralightparser.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: false
-require 'rexml/parsers/streamparser'
-require 'rexml/parsers/baseparser'
+require_relative 'streamparser'
+require_relative 'baseparser'
module REXML
module Parsers
diff --git a/lib/rexml/parsers/xpathparser.rb b/lib/rexml/parsers/xpathparser.rb
index 32b70bb798..bd3b6856eb 100644
--- a/lib/rexml/parsers/xpathparser.rb
+++ b/lib/rexml/parsers/xpathparser.rb
@@ -1,6 +1,7 @@
# frozen_string_literal: false
-require 'rexml/namespace'
-require 'rexml/xmltokens'
+
+require_relative '../namespace'
+require_relative '../xmltokens'
module REXML
module Parsers
@@ -22,7 +23,13 @@ def parse path
path.gsub!(/([\(\[])\s+/, '\1') # Strip ignorable spaces
path.gsub!( /\s+([\]\)])/, '\1')
parsed = []
- OrExpr(path, parsed)
+ rest = OrExpr(path, parsed)
+ if rest
+ unless rest.strip.empty?
+ raise ParseException.new("Garbage component exists at the end: " +
+ "<#{rest}>: <#{path}>")
+ end
+ end
parsed
end
@@ -32,108 +39,143 @@ def predicate path
parsed
end
- def abbreviate( path )
- path = path.kind_of?(String) ? parse( path ) : path
- string = ""
- document = false
- while path.size > 0
- op = path.shift
+ def abbreviate(path_or_parsed)
+ if path_or_parsed.kind_of?(String)
+ parsed = parse(path_or_parsed)
+ else
+ parsed = path_or_parsed
+ end
+ components = []
+ component = nil
+ while parsed.size > 0
+ op = parsed.shift
case op
when :node
+ component << "node()"
when :attribute
- string << "/" if string.size > 0
- string << "@"
+ component = "@"
+ components << component
when :child
- string << "/" if string.size > 0
+ component = ""
+ components << component
when :descendant_or_self
- string << "/"
+ next_op = parsed[0]
+ if next_op == :node
+ parsed.shift
+ component = ""
+ components << component
+ else
+ component = "descendant-or-self::"
+ components << component
+ end
when :self
- string << "."
+ next_op = parsed[0]
+ if next_op == :node
+ parsed.shift
+ components << "."
+ else
+ component = "self::"
+ components << component
+ end
when :parent
- string << ".."
+ next_op = parsed[0]
+ if next_op == :node
+ parsed.shift
+ components << ".."
+ else
+ component = "parent::"
+ components << component
+ end
when :any
- string << "*"
+ component << "*"
when :text
- string << "text()"
+ component << "text()"
when :following, :following_sibling,
:ancestor, :ancestor_or_self, :descendant,
:namespace, :preceding, :preceding_sibling
- string << "/" unless string.size == 0
- string << op.to_s.tr("_", "-")
- string << "::"
+ component = op.to_s.tr("_", "-") << "::"
+ components << component
when :qname
- prefix = path.shift
- name = path.shift
- string << prefix+":" if prefix.size > 0
- string << name
+ prefix = parsed.shift
+ name = parsed.shift
+ component << prefix+":" if prefix.size > 0
+ component << name
when :predicate
- string << '['
- string << predicate_to_string( path.shift ) {|x| abbreviate( x ) }
- string << ']'
+ component << '['
+ component << predicate_to_path(parsed.shift) {|x| abbreviate(x)}
+ component << ']'
when :document
- document = true
+ components << ""
when :function
- string << path.shift
- string << "( "
- string << predicate_to_string( path.shift[0] ) {|x| abbreviate( x )}
- string << " )"
+ component << parsed.shift
+ component << "( "
+ component << predicate_to_path(parsed.shift[0]) {|x| abbreviate(x)}
+ component << " )"
when :literal
- string << %Q{ "#{path.shift}" }
+ component << quote_literal(parsed.shift)
else
- string << "/" unless string.size == 0
- string << "UNKNOWN("
- string << op.inspect
- string << ")"
+ component << "UNKNOWN("
+ component << op.inspect
+ component << ")"
end
end
- string = "/"+string if document
- return string
+ case components
+ when [""]
+ "/"
+ when ["", ""]
+ "//"
+ else
+ components.join("/")
+ end
end
- def expand( path )
- path = path.kind_of?(String) ? parse( path ) : path
- string = ""
+ def expand(path_or_parsed)
+ if path_or_parsed.kind_of?(String)
+ parsed = parse(path_or_parsed)
+ else
+ parsed = path_or_parsed
+ end
+ path = ""
document = false
- while path.size > 0
- op = path.shift
+ while parsed.size > 0
+ op = parsed.shift
case op
when :node
- string << "node()"
+ path << "node()"
when :attribute, :child, :following, :following_sibling,
:ancestor, :ancestor_or_self, :descendant, :descendant_or_self,
:namespace, :preceding, :preceding_sibling, :self, :parent
- string << "/" unless string.size == 0
- string << op.to_s.tr("_", "-")
- string << "::"
+ path << "/" unless path.size == 0
+ path << op.to_s.tr("_", "-")
+ path << "::"
when :any
- string << "*"
+ path << "*"
when :qname
- prefix = path.shift
- name = path.shift
- string << prefix+":" if prefix.size > 0
- string << name
+ prefix = parsed.shift
+ name = parsed.shift
+ path << prefix+":" if prefix.size > 0
+ path << name
when :predicate
- string << '['
- string << predicate_to_string( path.shift ) { |x| expand(x) }
- string << ']'
+ path << '['
+ path << predicate_to_path( parsed.shift ) { |x| expand(x) }
+ path << ']'
when :document
document = true
else
- string << "/" unless string.size == 0
- string << "UNKNOWN("
- string << op.inspect
- string << ")"
+ path << "UNKNOWN("
+ path << op.inspect
+ path << ")"
end
end
- string = "/"+string if document
- return string
+ path = "/"+path if document
+ path
end
- def predicate_to_string( path, &block )
- string = ""
- case path[0]
+ def predicate_to_path(parsed, &block)
+ path = ""
+ case parsed[0]
when :and, :or, :mult, :plus, :minus, :neq, :eq, :lt, :gt, :lteq, :gteq, :div, :mod, :union
- op = path.shift
+ op = parsed.shift
case op
when :eq
op = "="
@@ -150,42 +192,56 @@ def predicate_to_string( path, &block )
when :union
op = "|"
end
- left = predicate_to_string( path.shift, &block )
- right = predicate_to_string( path.shift, &block )
- string << " "
- string << left
- string << " "
- string << op.to_s
- string << " "
- string << right
- string << " "
+ left = predicate_to_path( parsed.shift, &block )
+ right = predicate_to_path( parsed.shift, &block )
+ path << left
+ path << " "
+ path << op.to_s
+ path << " "
+ path << right
when :function
- path.shift
- name = path.shift
- string << name
- string << "( "
- string << predicate_to_string( path.shift, &block )
- string << " )"
+ parsed.shift
+ name = parsed.shift
+ path << name
+ path << "("
+ parsed.shift.each_with_index do |argument, i|
+ path << ", " if i > 0
+ path << predicate_to_path(argument, &block)
+ end
+ path << ")"
when :literal
- path.shift
- string << " "
- string << path.shift.inspect
- string << " "
+ parsed.shift
+ path << quote_literal(parsed.shift)
else
- string << " "
- string << yield( path )
- string << " "
+ path << yield( parsed )
end
- return string.squeeze(" ")
+ return path.squeeze(" ")
end
+ # For backward compatibility
+ alias_method :preciate_to_string, :predicate_to_path
private
+ def quote_literal( literal )
+ case literal
+ when String
+ # XPath 1.0 does not support escape characters.
+ # Assumes literal does not contain both single and double quotes.
+ if literal.include?("'")
+ "\"#{literal}\""
+ else
+ "'#{literal}'"
+ end
+ else
+ literal.inspect
+ end
+ end
+
#LocationPath
# | RelativeLocationPath
# | '/' RelativeLocationPath?
# | '//' RelativeLocationPath
def LocationPath path, parsed
- path = path.strip
+ path = path.lstrip
if path[0] == ?/
parsed << :document
if path[1] == ?/
@@ -209,7 +265,12 @@ def LocationPath path, parsed
# | RelativeLocationPath '//' Step
AXIS = /^(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::/
def RelativeLocationPath path, parsed
- while path.size > 0
+ loop do
+ original_path = path
+ path = path.lstrip
+
+ return original_path if path.empty?
+
# (axis or @ or <child::>) nodetest predicate >
# OR > / Step
# (. or ..) >
@@ -224,43 +285,44 @@ def RelativeLocationPath path, parsed
path = path[1..-1]
end
else
+ path_before_axis_specifier = path
+ parsed_not_abberviated = []
if path[0] == ?@
- parsed << :attribute
+ parsed_not_abberviated << :attribute
path = path[1..-1]
# Goto Nodetest
elsif path =~ AXIS
- parsed << $1.tr('-','_').intern
+ parsed_not_abberviated << $1.tr('-','_').intern
path = $'
# Goto Nodetest
else
- parsed << :child
+ parsed_not_abberviated << :child
end
- n = []
- path = NodeTest( path, n)
-
- if path[0] == ?[
- path = Predicate( path, n )
+ path_before_node_test = path
+ path = NodeTest(path, parsed_not_abberviated)
+ if path == path_before_node_test
+ return path_before_axis_specifier
end
+ path = Predicate(path, parsed_not_abberviated)
- parsed.concat(n)
+ parsed.concat(parsed_not_abberviated)
end
- if path.size > 0
- if path[0] == ?/
- if path[1] == ?/
- parsed << :descendant_or_self
- parsed << :node
- path = path[2..-1]
- else
- path = path[1..-1]
- end
- else
- return path
- end
+ original_path = path
+ path = path.lstrip
+ return original_path if path.empty?
+
+ return original_path if path[0] != ?/
+
+ if path[1] == ?/
+ parsed << :descendant_or_self
+ parsed << :node
+ path = path[2..-1]
+ else
+ path = path[1..-1]
end
end
- return path
end
# Returns a 1-1 map of the nodeset
@@ -269,15 +331,26 @@ def RelativeLocationPath path, parsed
# String, if a name match
#NodeTest
# | ('*' | NCNAME ':' '*' | QNAME) NameTest
- # | NODE_TYPE '(' ')' NodeType
+ # | '*' ':' NCNAME NameTest since XPath 2.0
+ # | NODE_TYPE '(' ')' NodeType
# | PI '(' LITERAL ')' PI
# | '[' expr ']' Predicate
- NCNAMETEST= /^(#{NCNAME_STR}):\*/u
+ PREFIX_WILDCARD = /^\*:(#{NCNAME_STR})/u
+ LOCAL_NAME_WILDCARD = /^(#{NCNAME_STR}):\*/u
QNAME = Namespace::NAMESPLIT
NODE_TYPE = /^(comment|text|node)\(\s*\)/m
PI = /^processing-instruction\(/
def NodeTest path, parsed
+ original_path = path
+ path = path.lstrip
case path
+ when PREFIX_WILDCARD
+ prefix = nil
+ name = $1
+ path = $'
+ parsed << :qname
+ parsed << prefix
+ parsed << name
when /^\*/
path = $'
parsed << :any
@@ -288,7 +361,9 @@ def NodeTest path, parsed
when PI
path = $'
literal = nil
- if path !~ /^\s*\)/
+ if path =~ /^\s*\)/
+ path = $'
+ else
path =~ LITERAL
literal = $1
path = $'
@@ -297,7 +372,7 @@ def NodeTest path, parsed
end
parsed << :processing_instruction
parsed << (literal || '')
- when NCNAMETEST
+ when LOCAL_NAME_WILDCARD
prefix = $1
path = $'
parsed << :namespace
@@ -310,13 +385,17 @@ def NodeTest path, parsed
parsed << :qname
parsed << prefix
parsed << name
+ else
+ path = original_path
end
return path
end
# Filters the supplied nodeset on the predicate(s)
def Predicate path, parsed
- return nil unless path[0] == ?[
+ original_path = path
+ path = path.lstrip
+ return original_path unless path[0] == ?[
predicates = []
while path[0] == ?[
path, expr = get_group(path)
@@ -421,13 +500,13 @@ def RelationalExpr path, parsed
rest
end
- #| AdditiveExpr ('+' | S '-') MultiplicativeExpr
+ #| AdditiveExpr ('+' | '-') MultiplicativeExpr
#| MultiplicativeExpr
def AdditiveExpr path, parsed
n = []
rest = MultiplicativeExpr( path, n )
if rest != path
- while rest =~ /^\s*(\+| -)\s*/
+ while rest =~ /^\s*(\+|-)\s*/
if $1[0] == ?+
n = [ :plus, n, [] ]
else
@@ -509,13 +588,14 @@ def UnionExpr path, parsed
#| LocationPath
#| FilterExpr ('/' | '//') RelativeLocationPath
def PathExpr path, parsed
- path =~ /^\s*/
- path = $'
+ path = path.lstrip
n = []
rest = FilterExpr( path, n )
if rest != path
if rest and rest[0] == ?/
- return RelativeLocationPath(rest, n)
+ rest = RelativeLocationPath(rest, n)
+ parsed.concat(n)
+ return rest
end
end
rest = LocationPath(rest, n) if rest =~ /\A[\/\.\@\[\w*]/
@@ -527,8 +607,10 @@ def PathExpr path, parsed
#| PrimaryExpr
def FilterExpr path, parsed
n = []
- path = PrimaryExpr( path, n )
- path = Predicate(path, n) if path and path[0] == ?[
+ path_before_primary_expr = path
+ path = PrimaryExpr(path, n)
+ return path_before_primary_expr if path == path_before_primary_expr
+ path = Predicate(path, n)
parsed.concat(n)
path
end
diff --git a/lib/rexml/quickpath.rb b/lib/rexml/quickpath.rb
index 5d6c77ca38..a0466b25d9 100644
--- a/lib/rexml/quickpath.rb
+++ b/lib/rexml/quickpath.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: false
-require 'rexml/functions'
-require 'rexml/xmltokens'
+require_relative 'functions'
+require_relative 'xmltokens'
module REXML
class QuickPath
diff --git a/lib/rexml/source.rb b/lib/rexml/source.rb
index af65cf4751..ff887fc080 100644
--- a/lib/rexml/source.rb
+++ b/lib/rexml/source.rb
@@ -1,8 +1,28 @@
# coding: US-ASCII
# frozen_string_literal: false
-require 'rexml/encoding'
+
+require "strscan"
+
+require_relative 'encoding'
module REXML
+ if StringScanner::Version < "1.0.0"
+ module StringScannerCheckScanString
+ refine StringScanner do
+ def check(pattern)
+ pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+ super(pattern)
+ end
+
+ def scan(pattern)
+ pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+ super(pattern)
+ end
+ end
+ end
+ using StringScannerCheckScanString
+ end
+
# Generates Source-s. USE THIS CLASS.
class SourceFactory
# Generates a Source object
@@ -30,18 +50,27 @@ def SourceFactory::create_from(arg)
# objects and provides consumption of text
class Source
include Encoding
- # The current buffer (what we're going to read next)
- attr_reader :buffer
# The line number of the last consumed text
attr_reader :line
attr_reader :encoding
+ module Private
+ SCANNER_RESET_SIZE = 100000
+ PRE_DEFINED_TERM_PATTERNS = {}
+ pre_defined_terms = ["'", '"', "<"]
+ pre_defined_terms.each do |term|
+ PRE_DEFINED_TERM_PATTERNS[term] = /#{Regexp.escape(term)}/
+ end
+ end
+ private_constant :Private
+
# Constructor
# @param arg must be a String, and should be a valid XML document
# @param encoding if non-null, sets the encoding of the source to this
# value, overriding all encoding detection
def initialize(arg, encoding=nil)
- @orig = @buffer = arg
+ @orig = arg
+ @scanner = StringScanner.new(@orig)
if encoding
self.encoding = encoding
else
@@ -50,6 +79,20 @@ def initialize(arg, encoding=nil)
@line = 0
end
+ # The current buffer (what we're going to read next)
+ def buffer
+ @scanner.rest
+ end
+
+ def drop_parsed_content
+ if @scanner.pos > Private::SCANNER_RESET_SIZE
+ @scanner.string = @scanner.rest
+ end
+ end
+
+ def buffer_encoding=(encoding)
+ @scanner.string.force_encoding(encoding)
+ end
# Inherited from Encoding
# Overridden to support optimized en/decoding
@@ -58,98 +101,78 @@ def encoding=(enc)
encoding_updated
end
- # Scans the source for a given pattern. Note, that this is not your
- # usual scan() method. For one thing, the pattern argument has some
- # requirements; for another, the source can be consumed. You can easily
- # confuse this method. Originally, the patterns were easier
- # to construct and this method more robust, because this method
- # generated search regexps on the fly; however, this was
- # computationally expensive and slowed down the entire REXML package
- # considerably, since this is by far the most commonly called method.
- # @param pattern must be a Regexp, and must be in the form of
- # /^\s*(#{your pattern, with no groups})(.*)/. The first group
- # will be returned; the second group is used if the consume flag is
- # set.
- # @param consume if true, the pattern returned will be consumed, leaving
- # everything after it in the Source.
- # @return the pattern, if found, or nil if the Source is empty or the
- # pattern is not found.
- def scan(pattern, cons=false)
- return nil if @buffer.nil?
- rv = @buffer.scan(pattern)
- @buffer = $' if cons and rv.size>0
- rv
+ def read(term = nil)
end
- def read
+ def read_until(term)
+ pattern = Private::PRE_DEFINED_TERM_PATTERNS[term] || /#{Regexp.escape(term)}/
+ data = @scanner.scan_until(pattern)
+ unless data
+ data = @scanner.rest
+ @scanner.pos = @scanner.string.bytesize
+ end
+ data
end
- def consume( pattern )
- @buffer = $' if pattern.match( @buffer )
+ def ensure_buffer
end
- def match_to( char, pattern )
- return pattern.match(@buffer)
+ def match(pattern, cons=false)
+ if cons
+ @scanner.scan(pattern).nil? ? nil : @scanner
+ else
+ @scanner.check(pattern).nil? ? nil : @scanner
+ end
end
- def match_to_consume( char, pattern )
- md = pattern.match(@buffer)
- @buffer = $'
- return md
+ def position
+ @scanner.pos
end
- def match(pattern, cons=false)
- md = pattern.match(@buffer)
- @buffer = $' if cons and md
- return md
+ def position=(pos)
+ @scanner.pos = pos
end
# @return true if the Source is exhausted
def empty?
- @buffer == ""
- end
-
- def position
- @orig.index( @buffer )
+ @scanner.eos?
end
# @return the current line in the source
def current_line
lines = @orig.split
- res = lines.grep @buffer[0..30]
+ res = lines.grep @scanner.rest[0..30]
res = res[-1] if res.kind_of? Array
lines.index( res ) if res
end
private
+
def detect_encoding
- buffer_encoding = @buffer.encoding
+ scanner_encoding = @scanner.rest.encoding
detected_encoding = "UTF-8"
begin
- @buffer.force_encoding("ASCII-8BIT")
- if @buffer[0, 2] == "\xfe\xff"
- @buffer[0, 2] = ""
+ @scanner.string.force_encoding("ASCII-8BIT")
+ if @scanner.scan(/\xfe\xff/n)
detected_encoding = "UTF-16BE"
- elsif @buffer[0, 2] == "\xff\xfe"
- @buffer[0, 2] = ""
+ elsif @scanner.scan(/\xff\xfe/n)
detected_encoding = "UTF-16LE"
- elsif @buffer[0, 3] == "\xef\xbb\xbf"
- @buffer[0, 3] = ""
+ elsif @scanner.scan(/\xef\xbb\xbf/n)
detected_encoding = "UTF-8"
end
ensure
- @buffer.force_encoding(buffer_encoding)
+ @scanner.string.force_encoding(scanner_encoding)
end
self.encoding = detected_encoding
end
def encoding_updated
if @encoding != 'UTF-8'
- @buffer = decode(@buffer)
+ @scanner.string = decode(@scanner.rest)
@to_utf = true
else
@to_utf = false
- @buffer.force_encoding ::Encoding::UTF_8
+ @scanner.string.force_encoding(::Encoding::UTF_8)
end
end
end
@@ -172,7 +195,7 @@ def initialize(arg, block_size=500, encoding=nil)
end
if !@to_utf and
- @buffer.respond_to?(:force_encoding) and
+ @orig.respond_to?(:force_encoding) and
@source.respond_to?(:external_encoding) and
@source.external_encoding != ::Encoding::UTF_8
@force_utf8 = true
@@ -181,65 +204,72 @@ def initialize(arg, block_size=500, encoding=nil)
end
end
- def scan(pattern, cons=false)
- rv = super
- # You'll notice that this next section is very similar to the same
- # section in match(), but just a liiittle different. This is
- # because it is a touch faster to do it this way with scan()
- # than the way match() does it; enough faster to warrant duplicating
- # some code
- if rv.size == 0
- until @buffer =~ pattern or @source.nil?
- begin
- @buffer << readline
- rescue Iconv::IllegalSequence
- raise
- rescue
- @source = nil
+ def read(term = nil, min_bytes = 1)
+ term = encode(term) if term
+ begin
+ str = readline(term)
+ @scanner << str
+ read_bytes = str.bytesize
+ begin
+ while read_bytes < min_bytes
+ str = readline(term)
+ @scanner << str
+ read_bytes += str.bytesize
end
+ rescue IOError
end
- rv = super
+ true
+ rescue Exception, NameError
+ @source = nil
+ false
end
- rv.taint
- rv
end
- def read
- begin
- @buffer << readline
- rescue Exception, NameError
- @source = nil
+ def read_until(term)
+ pattern = Private::PRE_DEFINED_TERM_PATTERNS[term] || /#{Regexp.escape(term)}/
+ term = encode(term)
+ until str = @scanner.scan_until(pattern)
+ break if @source.nil?
+ break if @source.eof?
+ @scanner << readline(term)
+ end
+ if str
+ read if @scanner.eos? and !@source.eof?
+ str
+ else
+ rest = @scanner.rest
+ @scanner.pos = @scanner.string.bytesize
+ rest
end
end
- def consume( pattern )
- match( pattern, true )
+ def ensure_buffer
+ read if @scanner.eos? && @source
end
def match( pattern, cons=false )
- rv = pattern.match(@buffer)
- @buffer = $' if cons and rv
- while !rv and @source
- begin
- @buffer << readline
- rv = pattern.match(@buffer)
- @buffer = $' if cons and rv
- rescue
- @source = nil
+ # To avoid performance issue, we need to increase bytes to read per scan
+ min_bytes = 1
+ while true
+ if cons
+ md = @scanner.scan(pattern)
+ else
+ md = @scanner.check(pattern)
end
+ break if md
+ return nil if pattern.is_a?(String)
+ return nil if @source.nil?
+ return nil unless read(nil, min_bytes)
+ min_bytes *= 2
end
- rv.taint
- rv
+
+ md.nil? ? nil : @scanner
end
def empty?
super and ( @source.nil? || @source.eof? )
end
- def position
- @er_source.pos rescue 0
- end
-
# @return the current line in the source
def current_line
begin
@@ -254,6 +284,7 @@ def current_line
end
rescue
end
+ @er_source.seek(pos)
rescue IOError
pos = -1
line = -1
@@ -262,8 +293,8 @@ def current_line
end
private
- def readline
- str = @source.readline(@line_break)
+ def readline(term = nil)
+ str = @source.readline(term || @line_break)
if @pending_buffer
if str.nil?
str = @pending_buffer
@@ -289,7 +320,7 @@ def encoding_updated
@source.set_encoding(@encoding, @encoding)
end
@line_break = encode(">")
- @pending_buffer, @buffer = @buffer, ""
+ @pending_buffer, @scanner.string = @scanner.rest, ""
@pending_buffer.force_encoding(@encoding)
super
end
diff --git a/lib/rexml/text.rb b/lib/rexml/text.rb
index 86269dea1e..997f77d3f5 100644
--- a/lib/rexml/text.rb
+++ b/lib/rexml/text.rb
@@ -1,10 +1,10 @@
-# frozen_string_literal: false
-require 'rexml/security'
-require 'rexml/entity'
-require 'rexml/doctype'
-require 'rexml/child'
-require 'rexml/doctype'
-require 'rexml/parseexception'
+# frozen_string_literal: true
+require_relative 'security'
+require_relative 'entity'
+require_relative 'doctype'
+require_relative 'child'
+require_relative 'doctype'
+require_relative 'parseexception'
module REXML
# Represents text nodes in an XML document
@@ -96,27 +96,28 @@ def initialize(arg, respect_whitespace=false, parent=nil, raw=nil,
@raw = false
@parent = nil
+ @entity_filter = nil
if parent
super( parent )
@raw = parent.raw
end
- @raw = raw unless raw.nil?
- @entity_filter = entity_filter
- clear_cache
-
if arg.kind_of? String
@string = arg.dup
- @string.squeeze!(" \n\t") unless respect_whitespace
elsif arg.kind_of? Text
- @string = arg.to_s
+ @string = arg.instance_variable_get(:@string).dup
@raw = arg.raw
- elsif
+ @entity_filter = arg.instance_variable_get(:@entity_filter)
+ else
raise "Illegal argument of type #{arg.type} for Text constructor (#{arg})"
end
- @string.gsub!( /\r\n?/, "\n" )
+ @string.squeeze!(" \n\t") unless respect_whitespace
+ @string.gsub!(/\r\n?/, "\n")
+ @raw = raw unless raw.nil?
+ @entity_filter = entity_filter if entity_filter
+ clear_cache
Text.check(@string, illegal, doctype) if @raw
end
@@ -130,13 +131,13 @@ def parent= parent
def Text.check string, pattern, doctype
# illegal anywhere
- if string !~ VALID_XML_CHARS
+ if !string.match?(VALID_XML_CHARS)
if String.method_defined? :encode
string.chars.each do |c|
case c.ord
when *VALID_CHAR
else
- raise "Illegal character #{c.inspect} in raw string \"#{string}\""
+ raise "Illegal character #{c.inspect} in raw string #{string.inspect}"
end
end
else
@@ -144,31 +145,51 @@ def Text.check string, pattern, doctype
case c.unpack('U')
when *VALID_CHAR
else
- raise "Illegal character #{c.inspect} in raw string \"#{string}\""
+ raise "Illegal character #{c.inspect} in raw string #{string.inspect}"
end
end
end
end
- # context sensitive
- string.scan(pattern) do
- if $1[-1] != ?;
- raise "Illegal character '#{$1}' in raw string \"#{string}\""
- elsif $1[0] == ?&
- if $5 and $5[0] == ?#
- case ($5[1] == ?x ? $5[2..-1].to_i(16) : $5[1..-1].to_i)
- when *VALID_CHAR
+ pos = 0
+ while (index = string.index(/<|&/, pos))
+ if string[index] == "<"
+ raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+ end
+
+ unless (end_index = string.index(/[^\s];/, index + 1))
+ raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+ end
+
+ value = string[(index + 1)..end_index]
+ if /\s/.match?(value)
+ raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+ end
+
+ if value[0] == "#"
+ character_reference = value[1..-1]
+
+ unless (/\A(\d+|x[0-9a-fA-F]+)\z/.match?(character_reference))
+ if character_reference[0] == "x" || character_reference[-1] == "x"
+ raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
else
- raise "Illegal character '#{$1}' in raw string \"#{string}\""
+ raise "Illegal character #{string.inspect} in raw string #{string.inspect}"
end
- # FIXME: below can't work but this needs API change.
- # elsif @parent and $3 and !SUBSTITUTES.include?($1)
- # if !doctype or !doctype.entities.has_key?($3)
- # raise "Undeclared entity '#{$1}' in raw string \"#{string}\""
- # end
end
+
+ case (character_reference[0] == "x" ? character_reference[1..-1].to_i(16) : character_reference[0..-1].to_i)
+ when *VALID_CHAR
+ else
+ raise "Illegal character #{string.inspect} in raw string #{string.inspect}"
+ end
+ elsif !(/\A#{Entity::NAME}\z/um.match?(value))
+ raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
end
+
+ pos = end_index + 1
end
+
+ string
end
def node_type
@@ -181,7 +202,7 @@ def empty?
def clone
- return Text.new(self)
+ return Text.new(self, true)
end
@@ -226,9 +247,7 @@ def doctype
# u.to_s #-> "sean russell"
def to_s
return @string if @raw
- return @normalized if @normalized
-
- @normalized = Text::normalize( @string, doctype, @entity_filter )
+ @normalized ||= Text::normalize( @string, doctype, @entity_filter )
end
def inspect
@@ -249,8 +268,8 @@ def inspect
# u = Text.new( "sean russell", false, nil, true )
# u.value #-> "sean russell"
def value
- return @unnormalized if @unnormalized
- @unnormalized = Text::unnormalize( @string, doctype )
+ @unnormalized ||= Text::unnormalize(@string, doctype,
+ entity_expansion_text_limit: document&.entity_expansion_text_limit)
end
# Sets the contents of this text node. This expects the text to be
@@ -266,16 +285,16 @@ def value=( val )
@raw = false
end
- def wrap(string, width, addnewline=false)
- # Recursively wrap string at width.
- return string if string.length <= width
- place = string.rindex(' ', width) # Position in string with last ' ' before cutoff
- if addnewline then
- return "\n" + string[0,place] + "\n" + wrap(string[place+1..-1], width)
- else
- return string[0,place] + "\n" + wrap(string[place+1..-1], width)
- end
- end
+ def wrap(string, width, addnewline=false)
+ # Recursively wrap string at width.
+ return string if string.length <= width
+ place = string.rindex(' ', width) # Position in string with last ' ' before cutoff
+ if addnewline then
+ return "\n" + string[0,place] + "\n" + wrap(string[place+1..-1], width)
+ else
+ return string[0,place] + "\n" + wrap(string[place+1..-1], width)
+ end
+ end
def indent_text(string, level=1, style="\t", indentfirstline=true)
return string if level < 0
@@ -373,7 +392,7 @@ def Text::normalize( input, doctype=nil, entity_filter=nil )
copy = input.to_s
# Doing it like this rather than in a loop improves the speed
#copy = copy.gsub( EREFERENCE, '&' )
- copy = copy.gsub( "&", "&" )
+ copy = copy.gsub( "&", "&" ) if copy.include?("&")
if doctype
# Replace all ampersands that aren't part of an entity
doctype.entities.each_value do |entity|
@@ -384,18 +403,21 @@ def Text::normalize( input, doctype=nil, entity_filter=nil )
else
# Replace all ampersands that aren't part of an entity
DocType::DEFAULT_ENTITIES.each_value do |entity|
- copy = copy.gsub(entity.value, "&#{entity.name};" )
+ if copy.include?(entity.value)
+ copy = copy.gsub(entity.value, "&#{entity.name};" )
+ end
end
end
copy
end
# Unescapes all possible entities
- def Text::unnormalize( string, doctype=nil, filter=nil, illegal=nil )
+ def Text::unnormalize( string, doctype=nil, filter=nil, illegal=nil, entity_expansion_text_limit: nil )
+ entity_expansion_text_limit ||= Security.entity_expansion_text_limit
sum = 0
string.gsub( /\r\n?/, "\n" ).gsub( REFERENCE ) {
s = Text.expand($&, doctype, filter)
- if sum + s.bytesize > Security.entity_expansion_text_limit
+ if sum + s.bytesize > entity_expansion_text_limit
raise "entity expansion has grown too large"
else
sum += s.bytesize
diff --git a/lib/rexml/undefinednamespaceexception.rb b/lib/rexml/undefinednamespaceexception.rb
index e522ed57ea..492a098183 100644
--- a/lib/rexml/undefinednamespaceexception.rb
+++ b/lib/rexml/undefinednamespaceexception.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require 'rexml/parseexception'
+require_relative 'parseexception'
module REXML
class UndefinedNamespaceException < ParseException
def initialize( prefix, source, parser )
diff --git a/lib/rexml/validation/relaxng.rb b/lib/rexml/validation/relaxng.rb
index fb52438290..f29a2c05e5 100644
--- a/lib/rexml/validation/relaxng.rb
+++ b/lib/rexml/validation/relaxng.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: false
-require "rexml/validation/validation"
-require "rexml/parsers/baseparser"
+require_relative "validation"
+require_relative "../parsers/baseparser"
module REXML
module Validation
diff --git a/lib/rexml/validation/validation.rb b/lib/rexml/validation/validation.rb
index f0c76f976c..0ad6ada427 100644
--- a/lib/rexml/validation/validation.rb
+++ b/lib/rexml/validation/validation.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: false
-require 'rexml/validation/validationexception'
+require_relative 'validationexception'
module REXML
module Validation
diff --git a/lib/rexml/xmldecl.rb b/lib/rexml/xmldecl.rb
index a37e9f3ddc..d19407cefd 100644
--- a/lib/rexml/xmldecl.rb
+++ b/lib/rexml/xmldecl.rb
@@ -1,17 +1,18 @@
# frozen_string_literal: false
-require 'rexml/encoding'
-require 'rexml/source'
+
+require_relative 'encoding'
+require_relative 'source'
module REXML
# NEEDS DOCUMENTATION
class XMLDecl < Child
include Encoding
- DEFAULT_VERSION = "1.0";
- DEFAULT_ENCODING = "UTF-8";
- DEFAULT_STANDALONE = "no";
- START = '<\?xml';
- STOP = '\?>';
+ DEFAULT_VERSION = "1.0"
+ DEFAULT_ENCODING = "UTF-8"
+ DEFAULT_STANDALONE = "no"
+ START = "<?xml"
+ STOP = "?>"
attr_accessor :version, :standalone
attr_reader :writeencoding, :writethis
@@ -25,6 +26,7 @@ def initialize(version=DEFAULT_VERSION, encoding=nil, standalone=nil)
self.encoding = version.encoding
@writeencoding = version.writeencoding
@standalone = version.standalone
+ @writethis = version.writethis
else
super()
@version = version
@@ -46,9 +48,9 @@ def clone
# Ignored
def write(writer, indent=-1, transitive=false, ie_hack=false)
return nil unless @writethis or writer.kind_of? Output
- writer << START.sub(/\\/u, '')
+ writer << START
writer << " #{content encoding}"
- writer << STOP.sub(/\\/u, '')
+ writer << STOP
end
def ==( other )
@@ -102,14 +104,26 @@ def dowrite
end
def inspect
- START.sub(/\\/u, '') + " ... " + STOP.sub(/\\/u, '')
+ "#{START} ... #{STOP}"
end
private
def content(enc)
- rv = "version='#@version'"
- rv << " encoding='#{enc}'" if @writeencoding || enc !~ /\Autf-8\z/i
- rv << " standalone='#@standalone'" if @standalone
+ context = nil
+ context = parent.context if parent
+ if context and context[:prologue_quote] == :quote
+ quote = "\""
+ else
+ quote = "'"
+ end
+
+ rv = "version=#{quote}#{@version}#{quote}"
+ if @writeencoding or enc !~ /\Autf-8\z/i
+ rv << " encoding=#{quote}#{enc}#{quote}"
+ end
+ if @standalone
+ rv << " standalone=#{quote}#{@standalone}#{quote}"
+ end
rv
end
end
diff --git a/lib/rexml/xpath.rb b/lib/rexml/xpath.rb
index f1cb99baea..a0921bd8e1 100644
--- a/lib/rexml/xpath.rb
+++ b/lib/rexml/xpath.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: false
-require 'rexml/functions'
-require 'rexml/xpath_parser'
+require_relative 'functions'
+require_relative 'xpath_parser'
module REXML
# Wrapper class. Use this class to access the XPath functions.
@@ -28,10 +28,10 @@ class XPath
# XPath.first( doc, "//b"} )
# XPath.first( node, "a/x:b", { "x"=>"http://doofus" } )
# XPath.first( node, '/book/publisher/text()=$publisher', {}, {"publisher"=>"O'Reilly"})
- def XPath::first element, path=nil, namespaces=nil, variables={}
+ def XPath::first(element, path=nil, namespaces=nil, variables={}, options={})
raise "The namespaces argument, if supplied, must be a hash object." unless namespaces.nil? or namespaces.kind_of?(Hash)
raise "The variables argument, if supplied, must be a hash object." unless variables.kind_of?(Hash)
- parser = XPathParser.new
+ parser = XPathParser.new(**options)
parser.namespaces = namespaces
parser.variables = variables
path = "*" unless path
@@ -57,10 +57,10 @@ def XPath::first element, path=nil, namespaces=nil, variables={}
# XPath.each( node, 'ancestor::x' ) { |el| ... }
# XPath.each( node, '/book/publisher/text()=$publisher', {}, {"publisher"=>"O'Reilly"}) \
# {|el| ... }
- def XPath::each element, path=nil, namespaces=nil, variables={}, &block
+ def XPath::each(element, path=nil, namespaces=nil, variables={}, options={}, &block)
raise "The namespaces argument, if supplied, must be a hash object." unless namespaces.nil? or namespaces.kind_of?(Hash)
raise "The variables argument, if supplied, must be a hash object." unless variables.kind_of?(Hash)
- parser = XPathParser.new
+ parser = XPathParser.new(**options)
parser.namespaces = namespaces
parser.variables = variables
path = "*" unless path
@@ -69,8 +69,8 @@ def XPath::each element, path=nil, namespaces=nil, variables={}, &block
end
# Returns an array of nodes matching a given XPath.
- def XPath::match element, path=nil, namespaces=nil, variables={}
- parser = XPathParser.new
+ def XPath::match(element, path=nil, namespaces=nil, variables={}, options={})
+ parser = XPathParser.new(**options)
parser.namespaces = namespaces
parser.variables = variables
path = "*" unless path
diff --git a/lib/rexml/xpath_parser.rb b/lib/rexml/xpath_parser.rb
index 181b2b6e85..5eb1e5a961 100644
--- a/lib/rexml/xpath_parser.rb
+++ b/lib/rexml/xpath_parser.rb
@@ -1,43 +1,51 @@
# frozen_string_literal: false
-require 'rexml/namespace'
-require 'rexml/xmltokens'
-require 'rexml/attribute'
-require 'rexml/syncenumerator'
-require 'rexml/parsers/xpathparser'
-
-class Object
- # provides a unified +clone+ operation, for REXML::XPathParser
- # to use across multiple Object types
- def dclone
- clone
- end
-end
-class Symbol
- # provides a unified +clone+ operation, for REXML::XPathParser
- # to use across multiple Object types
- def dclone ; self ; end
-end
-class Integer
- # provides a unified +clone+ operation, for REXML::XPathParser
- # to use across multiple Object types
- def dclone ; self ; end
-end
-class Float
- # provides a unified +clone+ operation, for REXML::XPathParser
- # to use across multiple Object types
- def dclone ; self ; end
-end
-class Array
- # provides a unified +clone+ operation, for REXML::XPathParser
- # to use across multiple Object+ types
- def dclone
- klone = self.clone
- klone.clear
- self.each{|v| klone << v.dclone}
- klone
+
+require "pp"
+
+require_relative 'namespace'
+require_relative 'xmltokens'
+require_relative 'attribute'
+require_relative 'parsers/xpathparser'
+
+module REXML
+ module DClonable
+ refine Object do
+ # provides a unified +clone+ operation, for REXML::XPathParser
+ # to use across multiple Object types
+ def dclone
+ clone
+ end
+ end
+ refine Symbol do
+ # provides a unified +clone+ operation, for REXML::XPathParser
+ # to use across multiple Object types
+ def dclone ; self ; end
+ end
+ refine Integer do
+ # provides a unified +clone+ operation, for REXML::XPathParser
+ # to use across multiple Object types
+ def dclone ; self ; end
+ end
+ refine Float do
+ # provides a unified +clone+ operation, for REXML::XPathParser
+ # to use across multiple Object types
+ def dclone ; self ; end
+ end
+ refine Array do
+ # provides a unified +clone+ operation, for REXML::XPathParser
+ # to use across multiple Object+ types
+ def dclone
+ klone = self.clone
+ klone.clear
+ self.each{|v| klone << v.dclone}
+ klone
+ end
+ end
end
end
+using REXML::DClonable
+
module REXML
# You don't want to use this class. Really. Use XPath, which is a wrapper
# for this class. Believe me. You don't want to poke around in here.
@@ -47,10 +55,15 @@ class XPathParser
include XMLTokens
LITERAL = /^'([^']*)'|^"([^"]*)"/u
- def initialize( )
+ DEBUG = (ENV["REXML_XPATH_PARSER_DEBUG"] == "true")
+
+ def initialize(strict: false)
+ @debug = DEBUG
@parser = REXML::Parsers::XPathParser.new
@namespaces = nil
@variables = {}
+ @nest = 0
+ @strict = strict
end
def namespaces=( namespaces={} )
@@ -75,7 +88,7 @@ def get_first path, nodeset
def predicate path, nodeset
path_stack = @parser.parse( path )
- expr( path_stack, nodeset )
+ match( path_stack, nodeset )
end
def []=( variable_name, value )
@@ -123,13 +136,24 @@ def first( path_stack, node )
end
- def match( path_stack, nodeset )
- r = expr( path_stack, nodeset )
- r
+ def match(path_stack, nodeset)
+ nodeset = nodeset.collect.with_index do |node, i|
+ position = i + 1
+ XPathNode.new(node, position: position)
+ end
+ result = expr(path_stack, nodeset)
+ case result
+ when Array # nodeset
+ unnode(result)
+ else
+ [result]
+ end
end
private
-
+ def strict?
+ @strict
+ end
# Returns a String namespace for a node, given a prefix
# The rules are:
@@ -148,343 +172,481 @@ def get_namespace( node, prefix )
# Expr takes a stack of path elements and a set of nodes (either a Parent
# or an Array and returns an Array of matching nodes
- ALL = [ :attribute, :element, :text, :processing_instruction, :comment ]
- ELEMENTS = [ :element ]
def expr( path_stack, nodeset, context=nil )
- node_types = ELEMENTS
+ enter(:expr, path_stack, nodeset) if @debug
return nodeset if path_stack.length == 0 || nodeset.length == 0
while path_stack.length > 0
+ trace(:while, path_stack, nodeset) if @debug
if nodeset.length == 0
path_stack.clear
return []
end
- case (op = path_stack.shift)
+ op = path_stack.shift
+ case op
when :document
- nodeset = [ nodeset[0].root_node ]
-
- when :qname
- prefix = path_stack.shift
- name = path_stack.shift
- nodeset.delete_if do |node|
- # FIXME: This DOUBLES the time XPath searches take
- ns = get_namespace( node, prefix )
- if node.node_type == :element
- if node.name == name
- end
- end
- !(node.node_type == :element and
- node.name == name and
- node.namespace == ns )
- end
- node_types = ELEMENTS
-
- when :any
- nodeset.delete_if { |node| !node_types.include?(node.node_type) }
-
+ first_raw_node = nodeset.first.raw_node
+ nodeset = [XPathNode.new(first_raw_node.root_node, position: 1)]
when :self
- # This space left intentionally blank
-
- when :processing_instruction
- target = path_stack.shift
- nodeset.delete_if do |node|
- (node.node_type != :processing_instruction) or
- ( target!='' and ( node.target != target ) )
+ nodeset = step(path_stack) do
+ [nodeset]
end
-
- when :text
- nodeset.delete_if { |node| node.node_type != :text }
-
- when :comment
- nodeset.delete_if { |node| node.node_type != :comment }
-
- when :node
- # This space left intentionally blank
- node_types = ALL
-
when :child
- new_nodeset = []
- nt = nil
- nodeset.each do |node|
- nt = node.node_type
- new_nodeset += node.children if nt == :element or nt == :document
+ nodeset = step(path_stack) do
+ child(nodeset)
end
- nodeset = new_nodeset
- node_types = ELEMENTS
-
when :literal
+ trace(:literal, path_stack, nodeset) if @debug
return path_stack.shift
-
when :attribute
- new_nodeset = []
- case path_stack.shift
- when :qname
- prefix = path_stack.shift
- name = path_stack.shift
- for element in nodeset
- if element.node_type == :element
- attrib = element.attribute( name, get_namespace(element, prefix) )
- new_nodeset << attrib if attrib
+ nodeset = step(path_stack, any_type: :attribute) do
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ next unless raw_node.node_type == :element
+ attributes = raw_node.attributes
+ next if attributes.empty?
+ nodesets << attributes.each_attribute.collect.with_index do |attribute, i|
+ XPathNode.new(attribute, position: i + 1)
end
end
- when :any
- for element in nodeset
- if element.node_type == :element
- new_nodeset += element.attributes.to_a
+ nodesets
+ end
+ when :namespace
+ pre_defined_namespaces = {
+ "xml" => "http://www.w3.org/XML/1998/namespace",
+ }
+ nodeset = step(path_stack, any_type: :namespace) do
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ case raw_node.node_type
+ when :element
+ if @namespaces
+ nodesets << pre_defined_namespaces.merge(@namespaces)
+ else
+ nodesets << pre_defined_namespaces.merge(raw_node.namespaces)
+ end
+ when :attribute
+ if @namespaces
+ nodesets << pre_defined_namespaces.merge(@namespaces)
+ else
+ nodesets << pre_defined_namespaces.merge(raw_node.element.namespaces)
+ end
end
end
+ nodesets
end
- nodeset = new_nodeset
-
when :parent
- nodeset = nodeset.collect{|n| n.parent}.compact
- #nodeset = expr(path_stack.dclone, nodeset.collect{|n| n.parent}.compact)
- node_types = ELEMENTS
-
- when :ancestor
- new_nodeset = []
- nodeset.each do |node|
- while node.parent
- node = node.parent
- new_nodeset << node unless new_nodeset.include? node
+ nodeset = step(path_stack) do
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ if raw_node.node_type == :attribute
+ parent = raw_node.element
+ else
+ parent = raw_node.parent
+ end
+ nodesets << [XPathNode.new(parent, position: 1)] if parent
end
+ nodesets
end
- nodeset = new_nodeset
- node_types = ELEMENTS
-
- when :ancestor_or_self
- new_nodeset = []
- nodeset.each do |node|
- if node.node_type == :element
- new_nodeset << node
- while ( node.parent )
- node = node.parent
- new_nodeset << node unless new_nodeset.include? node
+ when :ancestor
+ nodeset = step(path_stack) do
+ nodesets = []
+ # new_nodes = {}
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ new_nodeset = []
+ while raw_node.parent
+ raw_node = raw_node.parent
+ # next if new_nodes.key?(node)
+ new_nodeset << XPathNode.new(raw_node,
+ position: new_nodeset.size + 1)
+ # new_nodes[node] = true
end
+ nodesets << new_nodeset unless new_nodeset.empty?
end
+ nodesets
end
- nodeset = new_nodeset
- node_types = ELEMENTS
-
- when :predicate
- new_nodeset = []
- subcontext = { :size => nodeset.size }
- pred = path_stack.shift
- nodeset.each_with_index { |node, index|
- subcontext[ :node ] = node
- subcontext[ :index ] = index+1
- pc = pred.dclone
- result = expr( pc, [node], subcontext )
- result = result[0] if result.kind_of? Array and result.length == 1
- if result.kind_of? Numeric
- new_nodeset << node if result == (index+1)
- elsif result.instance_of? Array
- if result.size > 0 and result.inject(false) {|k,s| s or k}
- new_nodeset << node if result.size > 0
+ when :ancestor_or_self
+ nodeset = step(path_stack) do
+ nodesets = []
+ # new_nodes = {}
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ next unless raw_node.node_type == :element
+ new_nodeset = [XPathNode.new(raw_node, position: 1)]
+ # new_nodes[node] = true
+ while raw_node.parent
+ raw_node = raw_node.parent
+ # next if new_nodes.key?(node)
+ new_nodeset << XPathNode.new(raw_node,
+ position: new_nodeset.size + 1)
+ # new_nodes[node] = true
end
- else
- new_nodeset << node if result
+ nodesets << new_nodeset unless new_nodeset.empty?
end
- }
- nodeset = new_nodeset
-=begin
- predicate = path_stack.shift
- ns = nodeset.clone
- result = expr( predicate, ns )
- if result.kind_of? Array
- nodeset = result.zip(ns).collect{|m,n| n if m}.compact
- else
- nodeset = result ? nodeset : []
+ nodesets
end
-=end
-
when :descendant_or_self
- rv = descendant_or_self( path_stack, nodeset )
- path_stack.clear
- nodeset = rv
- node_types = ELEMENTS
-
+ nodeset = step(path_stack) do
+ descendant(nodeset, true)
+ end
when :descendant
- results = []
- nt = nil
- nodeset.each do |node|
- nt = node.node_type
- results += expr( path_stack.dclone.unshift( :descendant_or_self ),
- node.children ) if nt == :element or nt == :document
+ nodeset = step(path_stack) do
+ descendant(nodeset, false)
end
- nodeset = results
- node_types = ELEMENTS
-
when :following_sibling
- results = []
- nodeset.each do |node|
- next if node.parent.nil?
- all_siblings = node.parent.children
- current_index = all_siblings.index( node )
- following_siblings = all_siblings[ current_index+1 .. -1 ]
- results += expr( path_stack.dclone, following_siblings )
+ nodeset = step(path_stack) do
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ next unless raw_node.respond_to?(:parent)
+ next if raw_node.parent.nil?
+ all_siblings = raw_node.parent.children
+ current_index = all_siblings.index(raw_node)
+ following_siblings = all_siblings[(current_index + 1)..-1]
+ next if following_siblings.empty?
+ nodesets << following_siblings.collect.with_index do |sibling, i|
+ XPathNode.new(sibling, position: i + 1)
+ end
+ end
+ nodesets
end
- nodeset = results
-
when :preceding_sibling
- results = []
- nodeset.each do |node|
- next if node.parent.nil?
- all_siblings = node.parent.children
- current_index = all_siblings.index( node )
- preceding_siblings = all_siblings[ 0, current_index ].reverse
- results += preceding_siblings
+ nodeset = step(path_stack, order: :reverse) do
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ next unless raw_node.respond_to?(:parent)
+ next if raw_node.parent.nil?
+ all_siblings = raw_node.parent.children
+ current_index = all_siblings.index(raw_node)
+ preceding_siblings = all_siblings[0, current_index].reverse
+ next if preceding_siblings.empty?
+ nodesets << preceding_siblings.collect.with_index do |sibling, i|
+ XPathNode.new(sibling, position: i + 1)
+ end
+ end
+ nodesets
end
- nodeset = results
- node_types = ELEMENTS
-
when :preceding
- new_nodeset = []
- nodeset.each do |node|
- new_nodeset += preceding( node )
+ nodeset = step(path_stack, order: :reverse) do
+ unnode(nodeset) do |node|
+ preceding(node)
+ end
end
- nodeset = new_nodeset
- node_types = ELEMENTS
-
when :following
- new_nodeset = []
- nodeset.each do |node|
- new_nodeset += following( node )
- end
- nodeset = new_nodeset
- node_types = ELEMENTS
-
- when :namespace
- new_nodeset = []
- prefix = path_stack.shift
- nodeset.each do |node|
- if (node.node_type == :element or node.node_type == :attribute)
- if @namespaces
- namespaces = @namespaces
- elsif (node.node_type == :element)
- namespaces = node.namespaces
- else
- namespaces = node.element.namesapces
- end
- if (node.namespace == namespaces[prefix])
- new_nodeset << node
- end
+ nodeset = step(path_stack) do
+ unnode(nodeset) do |node|
+ following(node)
end
end
- nodeset = new_nodeset
-
when :variable
var_name = path_stack.shift
- return @variables[ var_name ]
+ return [@variables[var_name]]
- # :and, :or, :eq, :neq, :lt, :lteq, :gt, :gteq
- # TODO: Special case for :or and :and -- not evaluate the right
- # operand if the left alone determines result (i.e. is true for
- # :or and false for :and).
- when :eq, :neq, :lt, :lteq, :gt, :gteq, :or
+ when :eq, :neq, :lt, :lteq, :gt, :gteq
left = expr( path_stack.shift, nodeset.dup, context )
right = expr( path_stack.shift, nodeset.dup, context )
res = equality_relational_compare( left, op, right )
+ trace(op, left, right, res) if @debug
return res
+ when :or
+ left = expr(path_stack.shift, nodeset.dup, context)
+ return true if Functions.boolean(left)
+ right = expr(path_stack.shift, nodeset.dup, context)
+ return Functions.boolean(right)
+
when :and
- left = expr( path_stack.shift, nodeset.dup, context )
- return [] unless left
- if left.respond_to?(:inject) and !left.inject(false) {|a,b| a | b}
- return []
+ left = expr(path_stack.shift, nodeset.dup, context)
+ return false unless Functions.boolean(left)
+ right = expr(path_stack.shift, nodeset.dup, context)
+ return Functions.boolean(right)
+
+ when :div, :mod, :mult, :plus, :minus
+ left = expr(path_stack.shift, nodeset, context)
+ right = expr(path_stack.shift, nodeset, context)
+ left = unnode(left) if left.is_a?(Array)
+ right = unnode(right) if right.is_a?(Array)
+ left = Functions::number(left)
+ right = Functions::number(right)
+ case op
+ when :div
+ return left / right
+ when :mod
+ return left % right
+ when :mult
+ return left * right
+ when :plus
+ return left + right
+ when :minus
+ return left - right
+ else
+ raise "[BUG] Unexpected operator: <#{op.inspect}>"
end
- right = expr( path_stack.shift, nodeset.dup, context )
- res = equality_relational_compare( left, op, right )
- return res
-
- when :div
- left = Functions::number(expr(path_stack.shift, nodeset, context)).to_f
- right = Functions::number(expr(path_stack.shift, nodeset, context)).to_f
- return (left / right)
-
- when :mod
- left = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
- right = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
- return (left % right)
-
- when :mult
- left = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
- right = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
- return (left * right)
-
- when :plus
- left = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
- right = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
- return (left + right)
-
- when :minus
- left = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
- right = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
- return (left - right)
-
when :union
left = expr( path_stack.shift, nodeset, context )
right = expr( path_stack.shift, nodeset, context )
+ left = unnode(left) if left.is_a?(Array)
+ right = unnode(right) if right.is_a?(Array)
return (left | right)
-
when :neg
res = expr( path_stack, nodeset, context )
- return -(res.to_f)
-
+ res = unnode(res) if res.is_a?(Array)
+ return -Functions.number(res)
when :not
when :function
func_name = path_stack.shift.tr('-','_')
arguments = path_stack.shift
- subcontext = context ? nil : { :size => nodeset.size }
-
- res = []
- cont = context
- nodeset.each_with_index { |n, i|
- if subcontext
- subcontext[:node] = n
- subcontext[:index] = i
- cont = subcontext
+
+ if nodeset.size != 1
+ message = "[BUG] Node set size must be 1 for function call: "
+ message += "<#{func_name}>: <#{nodeset.inspect}>: "
+ message += "<#{arguments.inspect}>"
+ raise message
+ end
+
+ node = nodeset.first
+ if context
+ target_context = context
+ else
+ target_context = {:size => nodeset.size}
+ if node.is_a?(XPathNode)
+ target_context[:node] = node.raw_node
+ target_context[:index] = node.position
+ else
+ target_context[:node] = node
+ target_context[:index] = 1
end
- arg_clone = arguments.dclone
- args = arg_clone.collect { |arg|
- expr( arg, [n], cont )
- }
- Functions.context = cont
- res << Functions.send( func_name, *args )
- }
- return res
+ end
+ args = arguments.dclone.collect do |arg|
+ result = expr(arg, nodeset, target_context)
+ result = unnode(result) if result.is_a?(Array)
+ result
+ end
+ Functions.context = target_context
+ return Functions.send(func_name, *args)
+ else
+ raise "[BUG] Unexpected path: <#{op.inspect}>: <#{path_stack.inspect}>"
end
end # while
return nodeset
+ ensure
+ leave(:expr, path_stack, nodeset) if @debug
+ end
+
+ def step(path_stack, any_type: :element, order: :forward)
+ nodesets = yield
+ begin
+ enter(:step, path_stack, nodesets) if @debug
+ nodesets = node_test(path_stack, nodesets, any_type: any_type)
+ while path_stack[0] == :predicate
+ path_stack.shift # :predicate
+ predicate_expression = path_stack.shift.dclone
+ nodesets = evaluate_predicate(predicate_expression, nodesets)
+ end
+ if nodesets.size == 1
+ ordered_nodeset = nodesets[0]
+ else
+ raw_nodes = []
+ nodesets.each do |nodeset|
+ nodeset.each do |node|
+ if node.respond_to?(:raw_node)
+ raw_nodes << node.raw_node
+ else
+ raw_nodes << node
+ end
+ end
+ end
+ ordered_nodeset = sort(raw_nodes, order)
+ end
+ new_nodeset = []
+ ordered_nodeset.each do |node|
+ # TODO: Remove duplicated
+ new_nodeset << XPathNode.new(node, position: new_nodeset.size + 1)
+ end
+ new_nodeset
+ ensure
+ leave(:step, path_stack, new_nodeset) if @debug
+ end
end
+ def node_test(path_stack, nodesets, any_type: :element)
+ enter(:node_test, path_stack, nodesets) if @debug
+ operator = path_stack.shift
+ case operator
+ when :qname
+ prefix = path_stack.shift
+ name = path_stack.shift
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ case raw_node.node_type
+ when :element
+ if prefix.nil?
+ raw_node.name == name
+ elsif prefix.empty?
+ if strict?
+ raw_node.name == name and raw_node.namespace == ""
+ else
+ # FIXME: This DOUBLES the time XPath searches take
+ ns = get_namespace(raw_node, prefix)
+ raw_node.name == name and raw_node.namespace == ns
+ end
+ else
+ # FIXME: This DOUBLES the time XPath searches take
+ ns = get_namespace(raw_node, prefix)
+ raw_node.name == name and raw_node.namespace == ns
+ end
+ when :attribute
+ if prefix.nil?
+ raw_node.name == name
+ elsif prefix.empty?
+ raw_node.name == name and raw_node.namespace == ""
+ else
+ # FIXME: This DOUBLES the time XPath searches take
+ ns = get_namespace(raw_node.element, prefix)
+ raw_node.name == name and raw_node.namespace == ns
+ end
+ else
+ false
+ end
+ end
+ end
+ when :namespace
+ prefix = path_stack.shift
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ case raw_node.node_type
+ when :element
+ namespaces = @namespaces || raw_node.namespaces
+ raw_node.namespace == namespaces[prefix]
+ when :attribute
+ namespaces = @namespaces || raw_node.element.namespaces
+ raw_node.namespace == namespaces[prefix]
+ else
+ false
+ end
+ end
+ end
+ when :any
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ raw_node.node_type == any_type
+ end
+ end
+ when :comment
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ raw_node.node_type == :comment
+ end
+ end
+ when :text
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ raw_node.node_type == :text
+ end
+ end
+ when :processing_instruction
+ target = path_stack.shift
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ (raw_node.node_type == :processing_instruction) and
+ (target.empty? or (raw_node.target == target))
+ end
+ end
+ when :node
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ true
+ end
+ end
+ else
+ message = "[BUG] Unexpected node test: " +
+ "<#{operator.inspect}>: <#{path_stack.inspect}>"
+ raise message
+ end
+ new_nodesets
+ ensure
+ leave(:node_test, path_stack, new_nodesets) if @debug
+ end
- ##########################################################
- # FIXME
- # The next two methods are BAD MOJO!
- # This is my achilles heel. If anybody thinks of a better
- # way of doing this, be my guest. This really sucks, but
- # it is a wonder it works at all.
- # ########################################################
+ def filter_nodeset(nodeset)
+ new_nodeset = []
+ nodeset.each do |node|
+ next unless yield(node)
+ new_nodeset << XPathNode.new(node, position: new_nodeset.size + 1)
+ end
+ new_nodeset
+ end
- def descendant_or_self( path_stack, nodeset )
- rs = []
- d_o_s( path_stack, nodeset, rs )
- document_order(rs.flatten.compact)
- #rs.flatten.compact
+ def evaluate_predicate(expression, nodesets)
+ enter(:predicate, expression, nodesets) if @debug
+ new_nodeset_count = 0
+ new_nodesets = nodesets.collect do |nodeset|
+ new_nodeset = []
+ subcontext = { :size => nodeset.size }
+ nodeset.each_with_index do |node, index|
+ if node.is_a?(XPathNode)
+ subcontext[:node] = node.raw_node
+ subcontext[:index] = node.position
+ else
+ subcontext[:node] = node
+ subcontext[:index] = index + 1
+ end
+ result = expr(expression.dclone, [node], subcontext)
+ trace(:predicate_evaluate, expression, node, subcontext, result) if @debug
+ result = result[0] if result.kind_of? Array and result.length == 1
+ if result.kind_of? Numeric
+ if result == node.position
+ new_nodeset_count += 1
+ new_nodeset << XPathNode.new(node, position: new_nodeset_count)
+ end
+ elsif result.instance_of? Array
+ if result.size > 0 and result.inject(false) {|k,s| s or k}
+ if result.size > 0
+ new_nodeset_count += 1
+ new_nodeset << XPathNode.new(node, position: new_nodeset_count)
+ end
+ end
+ else
+ if result
+ new_nodeset_count += 1
+ new_nodeset << XPathNode.new(node, position: new_nodeset_count)
+ end
+ end
+ end
+ new_nodeset
+ end
+ new_nodesets
+ ensure
+ leave(:predicate, new_nodesets) if @debug
end
- def d_o_s( p, ns, r )
- nt = nil
- ns.each_index do |i|
- n = ns[i]
- x = expr( p.dclone, [ n ] )
- nt = n.node_type
- d_o_s( p, n.children, x ) if nt == :element or nt == :document and n.children.size > 0
- r.concat(x) if x.size > 0
+ def trace(*args)
+ indent = " " * @nest
+ PP.pp(args, "").each_line do |line|
+ puts("#{indent}#{line}")
end
end
+ def enter(tag, *args)
+ trace(:enter, tag, *args)
+ @nest += 1
+ end
+
+ def leave(tag, *args)
+ @nest -= 1
+ trace(:leave, tag, *args)
+ end
# Reorders an array of nodes so that they are in document order
# It tries to do this efficiently.
@@ -494,7 +656,7 @@ def d_o_s( p, ns, r )
# in and out of function calls. If I knew what the index of the nodes was,
# I wouldn't have to do this. Maybe add a document IDX for each node?
# Problems with mutable documents. Or, rewrite everything.
- def document_order( array_of_nodes )
+ def sort(array_of_nodes, order)
new_arry = []
array_of_nodes.each { |node|
node_idx = []
@@ -505,42 +667,68 @@ def document_order( array_of_nodes )
end
new_arry << [ node_idx.reverse, node ]
}
- new_arry.sort{ |s1, s2| s1[0] <=> s2[0] }.collect{ |s| s[1] }
+ ordered = new_arry.sort_by do |index, node|
+ if order == :forward
+ index
+ else
+ -index
+ end
+ end
+ ordered.collect do |_index, node|
+ node
+ end
end
-
- def recurse( nodeset, &block )
- for node in nodeset
- yield node
- recurse( node, &block ) if node.node_type == :element
+ def descendant(nodeset, include_self)
+ nodesets = []
+ nodeset.each do |node|
+ new_nodeset = []
+ new_nodes = {}
+ descendant_recursive(node.raw_node, new_nodeset, new_nodes, include_self)
+ nodesets << new_nodeset unless new_nodeset.empty?
end
+ nodesets
end
+ def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self)
+ if include_self
+ return if new_nodes.key?(raw_node)
+ new_nodeset << XPathNode.new(raw_node, position: new_nodeset.size + 1)
+ new_nodes[raw_node] = true
+ end
+ node_type = raw_node.node_type
+ if node_type == :element or node_type == :document
+ raw_node.children.each do |child|
+ descendant_recursive(child, new_nodeset, new_nodes, true)
+ end
+ end
+ end
# Builds a nodeset of all of the preceding nodes of the supplied node,
# in reverse document order
# preceding:: includes every element in the document that precedes this node,
# except for ancestors
- def preceding( node )
+ def preceding(node)
ancestors = []
- p = node.parent
- while p
- ancestors << p
- p = p.parent
+ parent = node.parent
+ while parent
+ ancestors << parent
+ parent = parent.parent
end
- acc = []
- p = preceding_node_of( node )
- while p
- if ancestors.include? p
- ancestors.delete(p)
+ precedings = []
+ preceding_node = preceding_node_of(node)
+ while preceding_node
+ if ancestors.include?(preceding_node)
+ ancestors.delete(preceding_node)
else
- acc << p
+ precedings << XPathNode.new(preceding_node,
+ position: precedings.size + 1)
end
- p = preceding_node_of( p )
+ preceding_node = preceding_node_of(preceding_node)
end
- acc
+ precedings
end
def preceding_node_of( node )
@@ -558,14 +746,15 @@ def preceding_node_of( node )
psn
end
- def following( node )
- acc = []
- p = next_sibling_node( node )
- while p
- acc << p
- p = following_node_of( p )
+ def following(node)
+ followings = []
+ following_node = next_sibling_node(node)
+ while following_node
+ followings << XPathNode.new(following_node,
+ position: followings.size + 1)
+ following_node = following_node_of(following_node)
end
- acc
+ followings
end
def following_node_of( node )
@@ -587,45 +776,68 @@ def next_sibling_node(node)
return psn
end
+ def child(nodeset)
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ node_type = raw_node.node_type
+ # trace(:child, node_type, node)
+ case node_type
+ when :element
+ nodesets << raw_node.children.collect.with_index do |child_node, i|
+ XPathNode.new(child_node, position: i + 1)
+ end
+ when :document
+ new_nodeset = []
+ raw_node.children.each do |child|
+ case child
+ when XMLDecl, Text
+ # Ignore
+ else
+ new_nodeset << XPathNode.new(child, position: new_nodeset.size + 1)
+ end
+ end
+ nodesets << new_nodeset unless new_nodeset.empty?
+ end
+ end
+ nodesets
+ end
+
def norm b
case b
when true, false
return b
when 'true', 'false'
return Functions::boolean( b )
- when /^\d+(\.\d+)?$/
+ when /^\d+(\.\d+)?$/, Numeric
return Functions::number( b )
else
return Functions::string( b )
end
end
- def equality_relational_compare( set1, op, set2 )
+ def equality_relational_compare(set1, op, set2)
+ set1 = unnode(set1) if set1.is_a?(Array)
+ set2 = unnode(set2) if set2.is_a?(Array)
+
if set1.kind_of? Array and set2.kind_of? Array
- if set1.size == 1 and set2.size == 1
- set1 = set1[0]
- set2 = set2[0]
- elsif set1.size == 0 or set2.size == 0
- nd = set1.size==0 ? set2 : set1
- rv = nd.collect { |il| compare( il, op, nil ) }
- return rv
- else
- res = []
- SyncEnumerator.new( set1, set2 ).each { |i1, i2|
- i1 = norm( i1 )
- i2 = norm( i2 )
- res << compare( i1, op, i2 )
- }
- return res
+ # If both objects to be compared are node-sets, then the
+ # comparison will be true if and only if there is a node in the
+ # first node-set and a node in the second node-set such that the
+ # result of performing the comparison on the string-values of
+ # the two nodes is true.
+ set1.product(set2).any? do |node1, node2|
+ node_string1 = Functions.string(node1)
+ node_string2 = Functions.string(node2)
+ compare(node_string1, op, node_string2)
end
- end
- # If one is nodeset and other is number, compare number to each item
- # in nodeset s.t. number op number(string(item))
- # If one is nodeset and other is string, compare string to each item
- # in nodeset s.t. string op string(item)
- # If one is nodeset and other is boolean, compare boolean to each item
- # in nodeset s.t. boolean op boolean(item)
- if set1.kind_of? Array or set2.kind_of? Array
+ elsif set1.kind_of? Array or set2.kind_of? Array
+ # If one is nodeset and other is number, compare number to each item
+ # in nodeset s.t. number op number(string(item))
+ # If one is nodeset and other is string, compare string to each item
+ # in nodeset s.t. string op string(item)
+ # If one is nodeset and other is boolean, compare boolean to each item
+ # in nodeset s.t. boolean op boolean(item)
if set1.kind_of? Array
a = set1
b = set2
@@ -636,15 +848,23 @@ def equality_relational_compare( set1, op, set2 )
case b
when true, false
- return a.collect {|v| compare( Functions::boolean(v), op, b ) }
+ each_unnode(a).any? do |unnoded|
+ compare(Functions.boolean(unnoded), op, b)
+ end
when Numeric
- return a.collect {|v| compare( Functions::number(v), op, b )}
- when /^\d+(\.\d+)?$/
- b = Functions::number( b )
- return a.collect {|v| compare( Functions::number(v), op, b )}
+ each_unnode(a).any? do |unnoded|
+ compare(Functions.number(unnoded), op, b)
+ end
+ when /\A\d+(\.\d+)?\z/
+ b = Functions.number(b)
+ each_unnode(a).any? do |unnoded|
+ compare(Functions.number(unnoded), op, b)
+ end
else
- b = Functions::string( b )
- return a.collect { |v| compare( Functions::string(v), op, b ) }
+ b = Functions::string(b)
+ each_unnode(a).any? do |unnoded|
+ compare(Functions::string(unnoded), op, b)
+ end
end
else
# If neither is nodeset,
@@ -654,32 +874,52 @@ def equality_relational_compare( set1, op, set2 )
# Else, convert to string
# Else
# Convert both to numbers and compare
- s1 = set1.to_s
- s2 = set2.to_s
- if s1 == 'true' or s1 == 'false' or s2 == 'true' or s2 == 'false'
- set1 = Functions::boolean( set1 )
- set2 = Functions::boolean( set2 )
+ compare(set1, op, set2)
+ end
+ end
+
+ def value_type(value)
+ case value
+ when true, false
+ :boolean
+ when Numeric
+ :number
+ when String
+ :string
+ else
+ raise "[BUG] Unexpected value type: <#{value.inspect}>"
+ end
+ end
+
+ def normalize_compare_values(a, operator, b)
+ a_type = value_type(a)
+ b_type = value_type(b)
+ case operator
+ when :eq, :neq
+ if a_type == :boolean or b_type == :boolean
+ a = Functions.boolean(a) unless a_type == :boolean
+ b = Functions.boolean(b) unless b_type == :boolean
+ elsif a_type == :number or b_type == :number
+ a = Functions.number(a) unless a_type == :number
+ b = Functions.number(b) unless b_type == :number
else
- if op == :eq or op == :neq
- if s1 =~ /^\d+(\.\d+)?$/ or s2 =~ /^\d+(\.\d+)?$/
- set1 = Functions::number( s1 )
- set2 = Functions::number( s2 )
- else
- set1 = Functions::string( set1 )
- set2 = Functions::string( set2 )
- end
- else
- set1 = Functions::number( set1 )
- set2 = Functions::number( set2 )
- end
+ a = Functions.string(a) unless a_type == :string
+ b = Functions.string(b) unless b_type == :string
end
- return compare( set1, op, set2 )
+ when :lt, :lteq, :gt, :gteq
+ a = Functions.number(a) unless a_type == :number
+ b = Functions.number(b) unless b_type == :number
+ else
+ message = "[BUG] Unexpected compare operator: " +
+ "<#{operator.inspect}>: <#{a.inspect}>: <#{b.inspect}>"
+ raise message
end
- return false
+ [a, b]
end
- def compare a, op, b
- case op
+ def compare(a, operator, b)
+ a, b = normalize_compare_values(a, operator, b)
+ case operator
when :eq
a == b
when :neq
@@ -692,13 +932,47 @@ def compare a, op, b
a > b
when :gteq
a >= b
- when :and
- a and b
- when :or
- a or b
else
- false
+ message = "[BUG] Unexpected compare operator: " +
+ "<#{operator.inspect}>: <#{a.inspect}>: <#{b.inspect}>"
+ raise message
+ end
+ end
+
+ def each_unnode(nodeset)
+ return to_enum(__method__, nodeset) unless block_given?
+ nodeset.each do |node|
+ if node.is_a?(XPathNode)
+ unnoded = node.raw_node
+ else
+ unnoded = node
+ end
+ yield(unnoded)
+ end
+ end
+
+ def unnode(nodeset)
+ each_unnode(nodeset).collect do |unnoded|
+ unnoded = yield(unnoded) if block_given?
+ unnoded
+ end
+ end
+ end
+
+ # @private
+ class XPathNode
+ attr_reader :raw_node, :context
+ def initialize(node, context=nil)
+ if node.is_a?(XPathNode)
+ @raw_node = node.raw_node
+ else
+ @raw_node = node
end
+ @context = context || {}
+ end
+
+ def position
+ @context[:position]
end
end
end
diff --git a/test/rexml/data/much_ado.xml b/test/rexml/data/much_ado.xml
index f008fadbb0..0040088c9c 100644
--- a/test/rexml/data/much_ado.xml
+++ b/test/rexml/data/much_ado.xml
@@ -4735,7 +4735,7 @@ CLAUDIO, BENEDICK, HERO, BEATRICE, and Attendants</STAGEDIR>
<LINE>But they shall find, awaked in such a kind,</LINE>
<LINE>Both strength of limb and policy of mind,</LINE>
<LINE>Ability in means and choice of friends,</LINE>
-<LINE>To quit me of them throughly.</LINE>
+<LINE>To quit me of them thoroughly.</LINE>
</SPEECH>
<SPEECH>
diff --git a/test/rexml/data/ofbiz-issues-full-177.xml b/test/rexml/data/ofbiz-issues-full-177.xml
index bfff771d12..e1f7bdfddc 100644
--- a/test/rexml/data/ofbiz-issues-full-177.xml
+++ b/test/rexml/data/ofbiz-issues-full-177.xml
@@ -152,8 +152,8 @@
<!-- desc : Short description for attachment. -->
<!-- ispatch : Whether attachment is a patch file. -->
<!-- filename : Filename of attachment. -->
- <!-- submitter_id : Issuezilla ID of attachement submitter. -->
- <!-- submitting_username : username of attachement submitter. -->
+ <!-- submitter_id : Issuezilla ID of attachment submitter. -->
+ <!-- submitting_username : username of attachment submitter. -->
<!-- data : Encoded attachment. -->
<!-- attachment_iz_url : URL to attachment in iz. -->
diff --git a/test/rexml/data/t75.xml b/test/rexml/data/t75.xml
index 0911fb1b1a..eb3cccee4b 100644
--- a/test/rexml/data/t75.xml
+++ b/test/rexml/data/t75.xml
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="ISO-8859-1"?><?pos="3"?>
+<?xml version="1.0" encoding="ISO-8859-1"?>
<!-- generated by hnb 1.9.17 (http://hnb.sourceforge.net) -->
<!DOCTYPE tree[
diff --git a/test/rexml/data/test/tests.xml b/test/rexml/data/test/tests.xml
index cf03b42b0b..fd415679c4 100644
--- a/test/rexml/data/test/tests.xml
+++ b/test/rexml/data/test/tests.xml
@@ -299,7 +299,7 @@
<valueOf select="name(/.)"></valueOf>
<valueOf select="name(/self::node())"></valueOf>
- <!-- name of root elemet -->
+ <!-- name of root element -->
<valueOf select="name(node())">web-app</valueOf>
<valueOf select="name(/node())">web-app</valueOf>
<valueOf select="name(/*)">web-app</valueOf>
@@ -318,7 +318,7 @@
<valueOf select="name(parent::node())"></valueOf>
<valueOf select="name(parent::*)"></valueOf>
- <!-- name of root elemet -->
+ <!-- name of root element -->
<valueOf select="name()">web-app</valueOf>
<valueOf select="name(.)">web-app</valueOf>
<valueOf select="name(../*)">web-app</valueOf>
diff --git a/test/rexml/data/tutorial.xml b/test/rexml/data/tutorial.xml
index bf5783d09a..9c4639b948 100644
--- a/test/rexml/data/tutorial.xml
+++ b/test/rexml/data/tutorial.xml
@@ -286,7 +286,7 @@ el1 << Text.new(" cruel world")
strings.</p>
<p>I can't emphasize this enough, because people do have problems with
- this. REXML can't possibly alway guess correctly how your text is
+ this. REXML can't possibly always guess correctly how your text is
encoded, so it always assumes the text is UTF-8. It also does not warn
you when you try to add text which isn't properly encoded, for the
same reason. You must make sure that you are adding UTF-8 text.
diff --git a/test/rexml/formatter/test_default.rb b/test/rexml/formatter/test_default.rb
new file mode 100644
index 0000000000..aa403dbed6
--- /dev/null
+++ b/test/rexml/formatter/test_default.rb
@@ -0,0 +1,17 @@
+module REXMLTests
+ class DefaultFormatterTest < Test::Unit::TestCase
+ def format(node)
+ formatter = REXML::Formatters::Default.new
+ output = +""
+ formatter.write(node, output)
+ output
+ end
+
+ class InstructionTest < self
+ def test_content_nil
+ instruction = REXML::Instruction.new("target")
+ assert_equal("<?target?>", format(instruction))
+ end
+ end
+ end
+end
diff --git a/test/rexml/functions/test_base.rb b/test/rexml/functions/test_base.rb
new file mode 100644
index 0000000000..daa38156f8
--- /dev/null
+++ b/test/rexml/functions/test_base.rb
@@ -0,0 +1,283 @@
+# frozen_string_literal: false
+require "test/unit/testcase"
+
+require "rexml/document"
+
+# TODO: Split me
+module REXMLTests
+ class FunctionsTester < Test::Unit::TestCase
+ include REXML
+
+ def setup
+ super
+ REXML::Functions.context = nil
+ end
+
+ def test_functions
+ # trivial text() test
+ # confuse-a-function
+ source = "<a>more <b id='1'/><b id='2'>dumb</b><b id='3'/><c/> text</a>"
+ doc = Document.new source
+ res = ""
+ XPath::each(doc.root, "text()") {|val| res << val.to_s}
+ assert_equal "more text", res
+
+ res = XPath::first(doc.root, "b[last()]")
+ assert_equal '3', res.attributes['id']
+ res = XPath::first(doc.root, "b[position()=2]")
+ assert_equal '2', res.attributes['id']
+ res = XPath::first(doc.root, "*[name()='c']")
+ assert_equal "c", res.name
+ end
+
+ # Contributed by Mike Stok
+ def test_starts_with
+ source = <<-EOF
+ <foo>
+ <a href="mailto:a@b.c">a@b.c</a>
+ <a href="http://www.foo.com">http://www.foo.com</a>
+ </foo>
+ EOF
+ doc = Document.new source
+ mailtos = doc.elements.to_a("//a[starts-with(@href, 'mailto:')]")
+ assert_equal 1, mailtos.size
+ assert_equal "mailto:a@b.c", mailtos[0].attributes['href']
+
+ ailtos = doc.elements.to_a("//a[starts-with(@href, 'ailto:')]")
+ assert_equal 0, ailtos.size
+ end
+
+ def test_string_length
+ doc = Document.new <<-EOF
+ <AAA>
+ <Q/>
+ <SSSS/>
+ <BB/>
+ <CCC/>
+ <DDDDDDDD/>
+ <EEEE/>
+ </AAA>
+ EOF
+ assert doc, "create doc"
+
+ set = doc.elements.to_a("//*[string-length(name()) = 3]")
+ assert_equal 2, set.size, "nodes with names length = 3"
+
+ set = doc.elements.to_a("//*[string-length(name()) < 3]")
+ assert_equal 2, set.size, "nodes with names length < 3"
+
+ set = doc.elements.to_a("//*[string-length(name()) > 3]")
+ assert_equal 3, set.size, "nodes with names length > 3"
+ end
+
+ # Test provided by Mike Stok
+ def test_contains
+ source = <<-EOF
+ <foo>
+ <a href="mailto:a@b.c">a@b.c</a>
+ <a href="http://www.foo.com">http://www.foo.com</a>
+ </foo>
+ EOF
+ doc = Document.new source
+
+ [['o', 2], ['foo', 1], ['bar', 0]].each { |test|
+ search, expected = test
+ set = doc.elements.to_a("//a[contains(@href, '#{search}')]")
+ assert_equal expected, set.size
+ }
+ end
+
+ # Mike Stok and Sean Russell
+ def test_substring
+ # examples from http://www.w3.org/TR/xpath#function-substring
+ doc = Document.new('<test string="12345" />')
+
+ #puts XPath.first(d, 'node()[0 + 1]')
+ #d = Document.new("<a b='1'/>")
+ #puts XPath.first(d, 'a[0 mod 0]')
+ [ [1.5, 2.6, '234'],
+ [0, 3, '12'],
+ [0, '0 div 0', ''],
+ [1, '0 div 0', ''],
+ ['-42', '1 div 0', '12345'],
+ ['-1 div 0', '1 div 0', '']
+ ].each { |start, length, expected|
+ set = doc.elements.to_a("//test[substring(@string, #{start}, #{length}) = '#{expected}']")
+ assert_equal 1, set.size, "#{start}, #{length}, '#{expected}'"
+ }
+ end
+
+ def test_substring_angrez
+ testString = REXML::Functions::substring_after("helloworld","hello")
+ assert_equal( 'world', testString )
+ end
+
+ def test_translate
+ source = <<-EOF
+ <doc>
+ <case name='w3c one' result='BAr' /> <!-- w3c -->
+ <case name='w3c two' result='AAA' /> <!-- w3c -->
+ <case name='alchemy' result="gold" /> <!-- mike -->
+ <case name='vbxml one' result='A Space Odyssey' />
+ <case name='vbxml two' result='AbCdEf' />
+ </doc>
+ EOF
+
+ doc = Document.new(source)
+
+ [ ['bar', 'abc', 'ABC', 'w3c one'],
+ ['--aaa--','abc-','ABC', 'w3c two'],
+ ['lead', 'dear language', 'doll groover', 'alchemy'],
+ ['A Space Odissei', 'i', 'y', 'vbxml one'],
+ ['abcdefg', 'aceg', 'ACE', 'vbxml two'],
+ ].each { |arg1, arg2, arg3, name|
+ translate = "translate('#{arg1}', '#{arg2}', '#{arg3}')"
+ set = doc.elements.to_a("//case[@result = #{translate}]")
+ assert_equal 1, set.size, translate
+ assert_equal name, set[0].attributes['name']
+ }
+ end
+
+ def test_name
+ d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")
+ assert_equal 1, d.root.elements.to_a('*[name() = "b"]').size
+ assert_equal 1, d.elements.to_a('//*[name() = "x:b"]').size
+ end
+
+ def test_local_name
+ d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")
+ assert_equal 2, d.root.elements.to_a('*[local_name() = "b"]').size
+ assert_equal 2, d.elements.to_a('//*[local_name() = "b"]').size
+ end
+
+ def test_substring2
+ doc = Document.new('<test string="12345" />')
+ assert_equal(1,doc.elements.to_a("//test[substring(@string,2)='2345']").size)
+ end
+
+ # Submitted by Kouhei
+ def test_floor_ceiling_round
+ source = "<a><b id='1'/><b id='2'/><b id='3'/></a>"
+ doc = REXML::Document.new(source)
+
+ id_1 = doc.elements["/a/b[@id='1']"]
+ id_2 = doc.elements["/a/b[@id='2']"]
+ id_3 = doc.elements["/a/b[@id='3']"]
+
+ good = {
+ "floor" => [[], [id_1], [id_2], [id_3]],
+ "ceiling" => [[id_1], [id_2], [id_3], []],
+ "round" => [[id_1], [id_2], [id_3], []]
+ }
+ good.each do |key, value|
+ (0..3).each do |i|
+ xpath = "//b[number(@id) = #{key}(#{i+0.5})]"
+ assert_equal(value[i], REXML::XPath.match(doc, xpath))
+ end
+ end
+
+ good["round"] = [[], [id_1], [id_2], [id_3]]
+ good.each do |key, value|
+ (0..3).each do |i|
+ xpath = "//b[number(@id) = #{key}(#{i+0.4})]"
+ assert_equal(value[i], REXML::XPath.match(doc, xpath))
+ end
+ end
+ end
+
+ # Submitted by Kou
+ def test_lang
+ d = Document.new(<<-XML)
+ <a xml:lang="en">
+ <b xml:lang="ja">
+ <c xml:lang="fr"/>
+ <d/>
+ <e xml:lang="ja-JP"/>
+ <f xml:lang="en-US"/>
+ </b>
+ </a>
+ XML
+
+ assert_equal(1, d.elements.to_a("//*[lang('fr')]").size)
+ assert_equal(3, d.elements.to_a("//*[lang('ja')]").size)
+ assert_equal(2, d.elements.to_a("//*[lang('en')]").size)
+ assert_equal(1, d.elements.to_a("//*[lang('en-us')]").size)
+
+ d = Document.new(<<-XML)
+ <root>
+ <para xml:lang="en"/>
+ <div xml:lang="en"><para/></div>
+ <para xml:lang="EN"/>
+ <para xml:lang="en-us"/>
+ </root>
+ XML
+
+ assert_equal(5, d.elements.to_a("//*[lang('en')]").size)
+ end
+
+ def test_ticket_60
+ document = REXML::Document.new("<a><b>A</b><b>1</b></a>")
+ assert_equal( "A", REXML::XPath.first(document, '//b[.="A"]').text )
+ assert_equal( "1", REXML::XPath.first(document, '//b[.="1"]').text )
+ end
+
+ def test_normalize_space
+ source = "<a><!--COMMENT A--><b><!-- COMMENT A --></b></a>"
+ doc = REXML::Document.new(source)
+ predicate = "string(.)=normalize_space('\nCOMMENT \n A \n\n ')"
+ m = REXML::XPath.match(doc, "//comment()[#{predicate}]")
+ assert_equal( [REXML::Comment.new("COMMENT A")], m )
+ end
+
+ def test_normalize_space_strings
+ source = <<-XML
+<a><b>breakfast boosts\t\t
+
+concentration </b><c>
+Coffee beans
+ aroma
+
+
+
+</c><d> Dessert
+ \t\t after dinner</d></a>
+ XML
+ normalized_texts = REXML::XPath.each(REXML::Document.new(source), "normalize-space(//text())").to_a
+ assert_equal([
+ "breakfast boosts concentration",
+ "Coffee beans aroma",
+ "Dessert after dinner",
+ ],
+ normalized_texts)
+ end
+
+ def test_string_nil_without_context
+ doc = REXML::Document.new(<<~XML)
+ <?xml version="1.0" encoding="UTF-8"?>
+ <root>
+ <foo bar="baz"/>
+ <foo bar=""/>
+ </root>
+ XML
+
+ assert_equal([doc.root.elements[2]],
+ REXML::XPath.match(doc,
+ "//foo[@bar=$n]",
+ nil,
+ {"n" => nil}))
+ end
+
+ def test_unregistered_method
+ doc = Document.new("<root/>")
+ assert_nil(XPath::first(doc.root, "to_s()"))
+ end
+
+ def test_nonexistent_function
+ doc = Document.new("<root><nonexistent/></root>")
+ # TODO: Maybe, this is not XPath spec behavior.
+ # This behavior must be reconsidered.
+ assert_equal(doc.root.elements[1],
+ XPath::first(doc.root, "nonexistent()"))
+ end
+ end
+end
diff --git a/test/rexml/functions/test_boolean.rb b/test/rexml/functions/test_boolean.rb
new file mode 100644
index 0000000000..b3e2117c10
--- /dev/null
+++ b/test/rexml/functions/test_boolean.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: false
+
+require "test/unit"
+require "rexml/document"
+require "rexml/functions"
+
+module REXMLTests
+ class TestFunctionsBoolean < Test::Unit::TestCase
+ def setup
+ REXML::Functions.context = nil
+ end
+
+ def test_true
+ assert_equal(true, REXML::Functions.boolean(true))
+ end
+
+ def test_false
+ assert_equal(false, REXML::Functions.boolean(false))
+ end
+
+ def test_integer_true
+ assert_equal(true, REXML::Functions.boolean(1))
+ end
+
+ def test_integer_positive_zero
+ assert_equal(false, REXML::Functions.boolean(0))
+ end
+
+ def test_integer_negative_zero
+ assert_equal(false, REXML::Functions.boolean(-0))
+ end
+
+ def test_float_true
+ assert_equal(true, REXML::Functions.boolean(1.1))
+ end
+
+ def test_float_positive_zero
+ assert_equal(false, REXML::Functions.boolean(-0.0))
+ end
+
+ def test_float_negative_zero
+ assert_equal(false, REXML::Functions.boolean(-0.0))
+ end
+
+ def test_float_nan
+ assert_equal(false, REXML::Functions.boolean(Float::NAN))
+ end
+
+ def test_string_true
+ assert_equal(true, REXML::Functions.boolean("content"))
+ end
+
+ def test_string_empty
+ assert_equal(false, REXML::Functions.boolean(""))
+ end
+
+ def test_node_set_true
+ root = REXML::Document.new("<root/>").root
+ assert_equal(true, REXML::Functions.boolean([root]))
+ end
+
+ def test_node_set_empty
+ assert_equal(false, REXML::Functions.boolean([]))
+ end
+
+ def test_nil
+ assert_equal(false, REXML::Functions.boolean(nil))
+ end
+
+ def test_context
+ REXML::Functions.context = {node: true}
+ assert_equal(true, REXML::Functions.boolean())
+ end
+ end
+end
diff --git a/test/rexml/functions/test_local_name.rb b/test/rexml/functions/test_local_name.rb
new file mode 100644
index 0000000000..97c9e74852
--- /dev/null
+++ b/test/rexml/functions/test_local_name.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: false
+
+require "test/unit"
+require "rexml/document"
+require "rexml/functions"
+
+module REXMLTests
+ class TestFunctionsLocalName < Test::Unit::TestCase
+ def setup
+ REXML::Functions.context = nil
+ end
+
+ def test_one
+ document = REXML::Document.new(<<-XML)
+<root xmlns:x="http://example.com/x/">
+ <x:child/>
+</root>
+ XML
+ node_set = document.root.children
+ assert_equal("child", REXML::Functions.local_name(node_set))
+ end
+
+ def test_multiple
+ document = REXML::Document.new(<<-XML)
+<root xmlns:x="http://example.com/x/">
+ <x:child1/>
+ <x:child2/>
+</root>
+ XML
+ node_set = document.root.children
+ assert_equal("child1", REXML::Functions.local_name(node_set))
+ end
+
+ def test_nonexistent
+ assert_equal("", REXML::Functions.local_name([]))
+ end
+
+ def test_context
+ document = REXML::Document.new("<root/>")
+ REXML::Functions.context = {node: document.root}
+ assert_equal("root", REXML::Functions.local_name())
+ end
+ end
+end
diff --git a/test/rexml/functions/test_number.rb b/test/rexml/functions/test_number.rb
new file mode 100644
index 0000000000..16e635701c
--- /dev/null
+++ b/test/rexml/functions/test_number.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: false
+
+require "test/unit"
+require "rexml/document"
+require "rexml/functions"
+
+module REXMLTests
+ class TestFunctionsNumber < Test::Unit::TestCase
+ def setup
+ REXML::Functions.context = nil
+ end
+
+ def test_true
+ assert_equal(1, REXML::Functions.number(true))
+ end
+
+ def test_false
+ assert_equal(0, REXML::Functions.number(false))
+ end
+
+ def test_numeric
+ assert_equal(29, REXML::Functions.number(29))
+ end
+
+ def test_string_integer
+ assert_equal(100, REXML::Functions.number("100"))
+ end
+
+ def test_string_float
+ assert_equal(-9.13, REXML::Functions.number("-9.13"))
+ end
+
+ def test_node_set
+ root = REXML::Document.new("<root>100</root>").root
+ assert_equal(100, REXML::Functions.number([root]))
+ end
+ end
+end
diff --git a/test/rexml/helper.rb b/test/rexml/helper.rb
new file mode 100644
index 0000000000..3de1327635
--- /dev/null
+++ b/test/rexml/helper.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: false
+
+require "test-unit"
+
+require "rexml/document"
+
+module Helper
+ module Fixture
+ def fixture_path(*components)
+ File.join(__dir__, "data", *components)
+ end
+ end
+
+ module Global
+ def suppress_warning
+ verbose = $VERBOSE
+ begin
+ $VERBOSE = nil
+ yield
+ ensure
+ $VERBOSE = verbose
+ end
+ end
+
+ def with_default_internal(encoding)
+ default_internal = Encoding.default_internal
+ begin
+ suppress_warning {Encoding.default_internal = encoding}
+ yield
+ ensure
+ suppress_warning {Encoding.default_internal = default_internal}
+ end
+ end
+ end
+end
diff --git a/test/rexml/parse/test_attribute_list_declaration.rb b/test/rexml/parse/test_attribute_list_declaration.rb
new file mode 100644
index 0000000000..4388252846
--- /dev/null
+++ b/test/rexml/parse/test_attribute_list_declaration.rb
@@ -0,0 +1,30 @@
+require "test/unit"
+require "core_assertions"
+
+require "rexml/document"
+
+module REXMLTests
+ class TestParseAttributeListDeclaration < Test::Unit::TestCase
+ include Test::Unit::CoreAssertions
+
+ def test_linear_performance_space
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new("<!DOCTYPE schema SYSTEM \"foo.dtd\" [<!ATTLIST " +
+ " " * n +
+ " root v CDATA #FIXED \"test\">]>")
+ end
+ end
+
+ def test_linear_performance_tab_and_gt
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new("<!DOCTYPE root [<!ATTLIST " +
+ "\t" * n +
+ "root value CDATA \"" +
+ ">" * n +
+ "\">]>")
+ end
+ end
+ end
+end
diff --git a/test/rexml/parse/test_cdata.rb b/test/rexml/parse/test_cdata.rb
new file mode 100644
index 0000000000..b5f1a3bc47
--- /dev/null
+++ b/test/rexml/parse/test_cdata.rb
@@ -0,0 +1,17 @@
+require "test/unit"
+require "core_assertions"
+
+require "rexml/document"
+
+module REXMLTests
+ class TestParseCData < Test::Unit::TestCase
+ include Test::Unit::CoreAssertions
+
+ def test_linear_performance_gt
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new('<description><![CDATA[ ' + ">" * n + ' ]]></description>')
+ end
+ end
+ end
+end
diff --git a/test/rexml/parse/test_character_reference.rb b/test/rexml/parse/test_character_reference.rb
new file mode 100644
index 0000000000..bf8d21903e
--- /dev/null
+++ b/test/rexml/parse/test_character_reference.rb
@@ -0,0 +1,17 @@
+require "test/unit"
+require "core_assertions"
+
+require "rexml/document"
+
+module REXMLTests
+ class TestParseCharacterReference < Test::Unit::TestCase
+ include Test::Unit::CoreAssertions
+
+ def test_linear_performance_many_preceding_zeros
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new('<test testing="&#' + "0" * n + '97;"/>')
+ end
+ end
+ end
+end
diff --git a/test/rexml/parse/test_comment.rb b/test/rexml/parse/test_comment.rb
new file mode 100644
index 0000000000..4475dca753
--- /dev/null
+++ b/test/rexml/parse/test_comment.rb
@@ -0,0 +1,151 @@
+require "test/unit"
+require "core_assertions"
+
+require "rexml/document"
+
+module REXMLTests
+ class TestParseComment < Test::Unit::TestCase
+ include Test::Unit::CoreAssertions
+
+ def parse(xml)
+ REXML::Document.new(xml)
+ end
+
+ class TestInvalid < self
+ def test_toplevel_unclosed_comment
+ exception = assert_raise(REXML::ParseException) do
+ parse("<!--")
+ end
+ assert_equal(<<~DETAIL, exception.to_s)
+ Unclosed comment
+ Line: 1
+ Position: 4
+ Last 80 unconsumed characters:
+ DETAIL
+ end
+
+ def test_toplevel_malformed_comment_inner
+ exception = assert_raise(REXML::ParseException) do
+ parse("<!-- -- -->")
+ end
+ assert_equal(<<~DETAIL, exception.to_s)
+ Malformed comment
+ Line: 1
+ Position: 11
+ Last 80 unconsumed characters:
+ DETAIL
+ end
+
+ def test_toplevel_malformed_comment_end
+ exception = assert_raise(REXML::ParseException) do
+ parse("<!-- --->")
+ end
+ assert_equal(<<~DETAIL, exception.to_s)
+ Malformed comment
+ Line: 1
+ Position: 9
+ Last 80 unconsumed characters:
+ DETAIL
+ end
+
+ def test_doctype_malformed_comment_inner
+ exception = assert_raise(REXML::ParseException) do
+ parse("<!DOCTYPE foo [<!-- -- -->")
+ end
+ assert_equal(<<~DETAIL, exception.to_s)
+ Malformed comment
+ Line: 1
+ Position: 26
+ Last 80 unconsumed characters:
+ DETAIL
+ end
+
+ def test_doctype_malformed_comment_end
+ exception = assert_raise(REXML::ParseException) do
+ parse("<!DOCTYPE foo [<!-- --->")
+ end
+ assert_equal(<<~DETAIL, exception.to_s)
+ Malformed comment
+ Line: 1
+ Position: 24
+ Last 80 unconsumed characters:
+ DETAIL
+ end
+
+ def test_after_doctype_malformed_comment_short
+ exception = assert_raise(REXML::ParseException) do
+ parse("<a><!-->")
+ end
+ assert_equal(<<~DETAIL.chomp, exception.to_s)
+ Malformed comment
+ Line: 1
+ Position: 8
+ Last 80 unconsumed characters:
+ -->
+ DETAIL
+ end
+
+ def test_after_doctype_malformed_comment_inner
+ exception = assert_raise(REXML::ParseException) do
+ parse("<a><!-- -- -->")
+ end
+ assert_equal(<<~DETAIL, exception.to_s)
+ Malformed comment
+ Line: 1
+ Position: 14
+ Last 80 unconsumed characters:
+ DETAIL
+ end
+
+ def test_after_doctype_malformed_comment_end
+ exception = assert_raise(REXML::ParseException) do
+ parse("<a><!-- --->")
+ end
+ assert_equal(<<~DETAIL, exception.to_s)
+ Malformed comment
+ Line: 1
+ Position: 12
+ Last 80 unconsumed characters:
+ DETAIL
+ end
+ end
+
+ def test_before_root
+ parser = REXML::Parsers::BaseParser.new('<!-- ok comment --><a></a>')
+
+ events = {}
+ while parser.has_next?
+ event = parser.pull
+ events[event[0]] = event[1]
+ end
+
+ assert_equal(" ok comment ", events[:comment])
+ end
+
+ def test_after_root
+ parser = REXML::Parsers::BaseParser.new('<a></a><!-- ok comment -->')
+
+ events = {}
+ while parser.has_next?
+ event = parser.pull
+ events[event[0]] = event[1]
+ end
+
+ assert_equal(" ok comment ", events[:comment])
+ end
+
+ def test_linear_performance_top_level_gt
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new('<!-- ' + ">" * n + ' -->')
+ end
+ end
+
+ def test_linear_performance_in_element_gt
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new('<xml><!-- ' + '>' * n + ' --></xml>')
+ end
+ end
+ end
+end
diff --git a/test/rexml/parse/test_document_type_declaration.rb b/test/rexml/parse/test_document_type_declaration.rb
index 55713909e7..99c23745a6 100644
--- a/test/rexml/parse/test_document_type_declaration.rb
+++ b/test/rexml/parse/test_document_type_declaration.rb
@@ -1,9 +1,13 @@
# frozen_string_literal: false
require "test/unit"
+require "core_assertions"
+
require "rexml/document"
module REXMLTests
class TestParseDocumentTypeDeclaration < Test::Unit::TestCase
+ include Test::Unit::CoreAssertions
+
private
def parse(doctype)
REXML::Document.new(<<-XML).doctype
@@ -36,6 +40,66 @@ def test_garbage_plus_before_name_at_line_start
+ r SYSTEM "urn:x-rexml:test" [ ]> <r/>
DETAIL
end
+
+ def test_no_name
+ exception = assert_raise(REXML::ParseException) do
+ parse(<<-DOCTYPE)
+<!DOCTYPE>
+ DOCTYPE
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed DOCTYPE: name is missing
+Line: 3
+Position: 17
+Last 80 unconsumed characters:
+<!DOCTYPE> <r/>
+ DETAIL
+ end
+ end
+
+ class TestUnclosed < self
+ def test_no_extra_node
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE foo [")
+ end
+ assert_equal(<<~DETAIL.chomp, exception.to_s)
+ Malformed DOCTYPE: unclosed
+ Line: 1
+ Position: 15
+ Last 80 unconsumed characters:
+
+ DETAIL
+ end
+
+ def test_start_element
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new(<<~DOCTYPE)
+ <!DOCTYPE foo [ <r>
+ DOCTYPE
+ end
+ assert_equal(<<~DETAIL.chomp, exception.to_s)
+ Malformed DOCTYPE: invalid declaration
+ Line: 1
+ Position: 20
+ Last 80 unconsumed characters:
+ <r>#{' '}
+ DETAIL
+ end
+
+ def test_text
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new(<<~DOCTYPE)
+ <!DOCTYPE foo [ text
+ DOCTYPE
+ end
+ assert_equal(<<~DETAIL.chomp, exception.to_s)
+ Malformed DOCTYPE: invalid declaration
+ Line: 1
+ Position: 21
+ Last 80 unconsumed characters:
+ text#{' '}
+ DETAIL
+ end
end
class TestExternalID < self
@@ -225,5 +289,29 @@ def parse(internal_subset)
DOCTYPE
end
end
+
+ def test_linear_performance_percent_gt
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ begin
+ REXML::Document.new("<!DOCTYPE root [" + "%>" * n + "]><test/>")
+ rescue
+ end
+ end
+ end
+
+ def test_linear_performance_comment_gt
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new("<!DOCTYPE root [<!-- " + ">" * n + " -->]>")
+ end
+ end
+
+ def test_linear_performance_external_entity_right_bracket_gt
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new("<!DOCTYPE root [%" + "]>" * n + ";]>")
+ end
+ end
end
end
diff --git a/test/rexml/parse/test_element.rb b/test/rexml/parse/test_element.rb
index e8dce4b997..ab4818dad9 100644
--- a/test/rexml/parse/test_element.rb
+++ b/test/rexml/parse/test_element.rb
@@ -1,8 +1,12 @@
require "test/unit"
+require "core_assertions"
+
require "rexml/document"
module REXMLTests
class TestParseElement < Test::Unit::TestCase
+ include Test::Unit::CoreAssertions
+
def parse(xml)
REXML::Document.new(xml)
end
@@ -43,7 +47,20 @@ def test_empty_namespace_attribute_name
Line: 1
Position: 13
Last 80 unconsumed characters:
+:a=""></x>
+ DETAIL
+ end
+ def test_empty_namespace_attribute_name_with_utf8_character
+ exception = assert_raise(REXML::ParseException) do
+ parse("<x :\xE2\x80\x8B>") # U+200B ZERO WIDTH SPACE
+ end
+ assert_equal(<<-DETAIL.chomp.force_encoding("ASCII-8BIT"), exception.to_s)
+Invalid attribute name: <:\xE2\x80\x8B>
+Line: 1
+Position: 8
+Last 80 unconsumed characters:
+:\xE2\x80\x8B>
DETAIL
end
@@ -72,6 +89,61 @@ def test_garbage_less_than_slash_before_end_tag_at_line_start
</ </x>
DETAIL
end
+
+ def test_after_root
+ exception = assert_raise(REXML::ParseException) do
+ parser = REXML::Parsers::BaseParser.new('<a></a><b>')
+ while parser.has_next?
+ parser.pull
+ end
+ end
+
+ assert_equal(<<~DETAIL.chomp, exception.to_s)
+ Malformed XML: Extra tag at the end of the document (got '<b')
+ Line: 1
+ Position: 10
+ Last 80 unconsumed characters:
+
+ DETAIL
+ end
+
+ def test_after_empty_element_tag_root
+ exception = assert_raise(REXML::ParseException) do
+ parser = REXML::Parsers::BaseParser.new('<a/><b>')
+ while parser.has_next?
+ parser.pull
+ end
+ end
+
+ assert_equal(<<~DETAIL.chomp, exception.to_s)
+ Malformed XML: Extra tag at the end of the document (got '<b')
+ Line: 1
+ Position: 7
+ Last 80 unconsumed characters:
+
+ DETAIL
+ end
+ end
+
+ def test_linear_performance_attribute_value_gt
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new('<test testing="' + ">" * n + '"></test>')
+ end
+ end
+
+ def test_linear_performance_deep_same_name_attributes
+ seq = [100, 500, 1000, 1500, 2000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ xml = <<-XML
+<?xml version="1.0"?>
+<root xmlns:ns="ns-uri">
+#{"<x ns:name='ns-value' name='value'>\n" * n}
+#{"</x>\n" * n}
+</root>
+ XML
+ REXML::Document.new(xml)
+ end
end
end
end
diff --git a/test/rexml/parse/test_entity_declaration.rb b/test/rexml/parse/test_entity_declaration.rb
new file mode 100644
index 0000000000..81d95b5868
--- /dev/null
+++ b/test/rexml/parse/test_entity_declaration.rb
@@ -0,0 +1,557 @@
+# frozen_string_literal: false
+require "test/unit"
+require "core_assertions"
+
+require "rexml/document"
+
+module REXMLTests
+ class TestParseEntityDeclaration < Test::Unit::TestCase
+ include Test::Unit::CoreAssertions
+
+ private
+ def xml(internal_subset)
+ <<-XML
+<!DOCTYPE r SYSTEM "urn:x-henrikmartensson:test" [
+#{internal_subset}
+]>
+<r/>
+ XML
+ end
+
+ def parse(internal_subset)
+ REXML::Document.new(xml(internal_subset)).doctype
+ end
+
+ public
+
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-GEDecl
+ class TestGeneralEntityDeclaration < self
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-Name
+ class TestName < self
+ def test_prohibited_character
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY invalid&name \"valid-entity-value\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 61
+Last 80 unconsumed characters:
+ invalid&name "valid-entity-value">]>
+ DETAIL
+ end
+ end
+
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EntityDef
+ class TestEntityDefinition < self
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EntityValue
+ class TestEntityValue < self
+ def test_no_quote
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name invalid-entity-value>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 59
+Last 80 unconsumed characters:
+ valid-name invalid-entity-value>]>
+ DETAIL
+ end
+
+ def test_prohibited_character
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name \"% &\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 44
+Last 80 unconsumed characters:
+ valid-name "% &">]>
+ DETAIL
+ end
+
+ def test_mixed_quote
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name \"invalid-entity-value'>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 61
+Last 80 unconsumed characters:
+ valid-name "invalid-entity-value'>]>
+ DETAIL
+ end
+ end
+
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-ExternalID
+ class TestExternalID < self
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-SystemLiteral
+ class TestSystemLiteral < self
+ def test_no_quote_in_system
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name SYSTEM invalid-system-literal>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 68
+Last 80 unconsumed characters:
+ valid-name SYSTEM invalid-system-literal>]>
+ DETAIL
+ end
+
+ def test_no_quote_in_public
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name PUBLIC \"valid-pubid-literal\" invalid-system-literal>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 90
+Last 80 unconsumed characters:
+ valid-name PUBLIC "valid-pubid-literal" invalid-system-literal>]>
+ DETAIL
+ end
+
+ def test_mixed_quote_in_system
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name SYSTEM 'invalid-system-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 70
+Last 80 unconsumed characters:
+ valid-name SYSTEM 'invalid-system-literal">]>
+ DETAIL
+ end
+
+ def test_mixed_quote_in_public
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name PUBLIC \"valid-pubid-literal\" \"invalid-system-literal'>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 92
+Last 80 unconsumed characters:
+ valid-name PUBLIC "valid-pubid-literal" "invalid-system-literal'>]>
+ DETAIL
+ end
+
+ def test_no_literal_in_system
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name SYSTEM>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 45
+Last 80 unconsumed characters:
+ valid-name SYSTEM>]>
+ DETAIL
+ end
+
+ def test_no_literal_in_public
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name PUBLIC \"valid-pubid-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 67
+Last 80 unconsumed characters:
+ valid-name PUBLIC "valid-pubid-literal">]>
+ DETAIL
+ end
+ end
+
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-PubidLiteral
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-PubidChar
+ class TestPublicIDLiteral < self
+ def test_no_quote
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name PUBLIC invalid-pubid-literal \"valid-system-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 90
+Last 80 unconsumed characters:
+ valid-name PUBLIC invalid-pubid-literal "valid-system-literal">]>
+ DETAIL
+ end
+
+ def test_prohibited_pubid_character
+ exception = assert_raise(REXML::ParseException) do
+ # U+3042 HIRAGANA LETTER A
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name PUBLIC \"\u3042\" \"valid-system-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.force_encoding('utf-8').chomp, exception.to_s.force_encoding('utf-8'))
+Malformed entity declaration
+Line: 1
+Position: 74
+Last 80 unconsumed characters:
+ valid-name PUBLIC "\u3042" "valid-system-literal">]>
+ DETAIL
+ end
+
+ def test_mixed_quote
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name PUBLIC \"invalid-pubid-literal' \"valid-system-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 92
+Last 80 unconsumed characters:
+ valid-name PUBLIC "invalid-pubid-literal' "valid-system-literal">]>
+ DETAIL
+ end
+
+ def test_no_literal
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name PUBLIC>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 45
+Last 80 unconsumed characters:
+ valid-name PUBLIC>]>
+ DETAIL
+ end
+ end
+ end
+
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-NDataDecl
+ class TestNotationDataDeclaration < self
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-NameChar
+ def test_prohibited_character
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name PUBLIC \"valid-pubid-literal\" \"valid-system-literal\" NDATA invalid&name>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 109
+Last 80 unconsumed characters:
+ valid-name PUBLIC "valid-pubid-literal" "valid-system-literal" NDATA invalid&nam
+ DETAIL
+ end
+ end
+
+ def test_entity_value_and_notation_data_declaration
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-name \"valid-entity-value\" NDATA valid-ndata-value>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 83
+Last 80 unconsumed characters:
+ valid-name "valid-entity-value" NDATA valid-ndata-value>]>
+ DETAIL
+ end
+ end
+
+ def test_no_space
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY valid-namePUBLIC\"valid-pubid-literal\"\"valid-system-literal\"NDATAvalid-name>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 102
+Last 80 unconsumed characters:
+ valid-namePUBLIC"valid-pubid-literal""valid-system-literal"NDATAvalid-name>]>
+ DETAIL
+ end
+ end
+
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-PEDecl
+ class TestParsedEntityDeclaration < self
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-Name
+ class TestName < self
+ def test_prohibited_character
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % invalid&name \"valid-entity-value\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 63
+Last 80 unconsumed characters:
+ % invalid&name "valid-entity-value">]>
+ DETAIL
+ end
+ end
+
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-PEDef
+ class TestParsedEntityDefinition < self
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EntityValue
+ class TestEntityValue < self
+ def test_no_quote
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name invalid-entity-value>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 61
+Last 80 unconsumed characters:
+ % valid-name invalid-entity-value>]>
+ DETAIL
+ end
+
+ def test_prohibited_character
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name \"% &\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 46
+Last 80 unconsumed characters:
+ % valid-name "% &">]>
+ DETAIL
+ end
+
+ def test_mixed_quote
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name 'invalid-entity-value\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 63
+Last 80 unconsumed characters:
+ % valid-name 'invalid-entity-value">]>
+ DETAIL
+ end
+ end
+
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-ExternalID
+ class TestExternalID < self
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-SystemLiteral
+ class TestSystemLiteral < self
+ def test_no_quote_in_system
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name SYSTEM invalid-system-literal>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 70
+Last 80 unconsumed characters:
+ % valid-name SYSTEM invalid-system-literal>]>
+ DETAIL
+ end
+
+ def test_no_quote_in_public
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name PUBLIC \"valid-pubid-literal\" invalid-system-literal>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 92
+Last 80 unconsumed characters:
+ % valid-name PUBLIC "valid-pubid-literal" invalid-system-literal>]>
+ DETAIL
+ end
+
+ def test_mixed_quote_in_system
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name SYSTEM \"invalid-system-literal'>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 72
+Last 80 unconsumed characters:
+ % valid-name SYSTEM "invalid-system-literal'>]>
+ DETAIL
+ end
+
+ def test_mixed_quote_in_public
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name PUBLIC \"valid-pubid-literal\" 'invalid-system-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 94
+Last 80 unconsumed characters:
+ % valid-name PUBLIC "valid-pubid-literal" 'invalid-system-literal">]>
+ DETAIL
+ end
+
+ def test_no_literal_in_system
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name SYSTEM>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 47
+Last 80 unconsumed characters:
+ % valid-name SYSTEM>]>
+ DETAIL
+ end
+
+ def test_no_literal_in_public
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name PUBLIC \"valid-pubid-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 69
+Last 80 unconsumed characters:
+ % valid-name PUBLIC "valid-pubid-literal">]>
+ DETAIL
+ end
+ end
+
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-PubidLiteral
+ # https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-PubidChar
+ class TestPublicIDLiteral < self
+ def test_no_quote
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name PUBLIC invalid-pubid-literal \"valid-system-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 92
+Last 80 unconsumed characters:
+ % valid-name PUBLIC invalid-pubid-literal "valid-system-literal">]>
+ DETAIL
+ end
+
+ def test_prohibited_pubid_character
+ exception = assert_raise(REXML::ParseException) do
+ # U+3042 HIRAGANA LETTER A
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name PUBLIC \"\u3042\" \"valid-system-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.force_encoding('utf-8').chomp, exception.to_s.force_encoding('utf-8'))
+Malformed entity declaration
+Line: 1
+Position: 76
+Last 80 unconsumed characters:
+ % valid-name PUBLIC "\u3042" "valid-system-literal">]>
+ DETAIL
+ end
+
+ def test_mixed_quote
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name PUBLIC 'invalid-pubid-literal\" \"valid-system-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 94
+Last 80 unconsumed characters:
+ % valid-name PUBLIC 'invalid-pubid-literal" "valid-system-literal">]>
+ DETAIL
+ end
+
+ def test_no_literal
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name PUBLIC>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 47
+Last 80 unconsumed characters:
+ % valid-name PUBLIC>]>
+ DETAIL
+ end
+ end
+ end
+
+ def test_entity_value_and_notation_data_declaration
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY % valid-name \"valid-entity-value\" NDATA valid-ndata-value>]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 85
+Last 80 unconsumed characters:
+ % valid-name "valid-entity-value" NDATA valid-ndata-value>]>
+ DETAIL
+ end
+ end
+
+ def test_no_space
+ exception = assert_raise(REXML::ParseException) do
+ REXML::Document.new("<!DOCTYPE root [<!ENTITY %valid-nameSYSTEM\"valid-system-literal\">]>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 1
+Position: 67
+Last 80 unconsumed characters:
+ %valid-nameSYSTEM"valid-system-literal">]>
+ DETAIL
+ end
+ end
+
+ def test_empty
+ exception = assert_raise(REXML::ParseException) do
+ parse(<<-INTERNAL_SUBSET)
+<!ENTITY>
+ INTERNAL_SUBSET
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed entity declaration
+Line: 5
+Position: 70
+Last 80 unconsumed characters:
+> ]> <r/>
+ DETAIL
+ end
+
+ def test_linear_performance_entity_value_gt
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new("<!DOCTYPE rubynet [<!ENTITY rbconfig.ruby_version \"" +
+ ">" * n +
+ "\">]>")
+ end
+ end
+
+ def test_linear_performance_entity_value_gt_right_bracket
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new("<!DOCTYPE rubynet [<!ENTITY rbconfig.ruby_version \"" +
+ ">]" * n +
+ "\">]>")
+ end
+ end
+
+ def test_linear_performance_system_literal_in_system_gt_right_bracket
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new("<!DOCTYPE rubynet [<!ENTITY rbconfig.ruby_version SYSTEM \"" +
+ ">]" * n +
+ "\">]>")
+ end
+ end
+
+ def test_linear_performance_system_literal_in_public_gt_right_bracket
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new("<!DOCTYPE rubynet [<!ENTITY rbconfig.ruby_version PUBLIC \"pubid-literal\" \"" +
+ ">]" * n +
+ "\">]>")
+ end
+ end
+ end
+end
diff --git a/test/rexml/parse/test_notation_declaration.rb b/test/rexml/parse/test_notation_declaration.rb
index 19a0536d0a..9e81b6a428 100644
--- a/test/rexml/parse/test_notation_declaration.rb
+++ b/test/rexml/parse/test_notation_declaration.rb
@@ -35,7 +35,7 @@ def test_no_name
Line: 5
Position: 72
Last 80 unconsumed characters:
- <!NOTATION> ]> <r/>
+<!NOTATION> ]> <r/>
DETAIL
end
diff --git a/test/rexml/parse/test_processing_instruction.rb b/test/rexml/parse/test_processing_instruction.rb
new file mode 100644
index 0000000000..ba381dc4cd
--- /dev/null
+++ b/test/rexml/parse/test_processing_instruction.rb
@@ -0,0 +1,127 @@
+require "test/unit"
+require "core_assertions"
+
+require "rexml/document"
+
+module REXMLTests
+ class TestParseProcessingInstruction < Test::Unit::TestCase
+ include Test::Unit::CoreAssertions
+
+ def parse(xml)
+ REXML::Document.new(xml)
+ end
+
+ class TestInvalid < self
+ def test_no_name
+ exception = assert_raise(REXML::ParseException) do
+ parse("<??>")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed XML: Invalid processing instruction node: invalid name
+Line: 1
+Position: 4
+Last 80 unconsumed characters:
+?>
+ DETAIL
+ end
+
+ def test_unclosed_content
+ exception = assert_raise(REXML::ParseException) do
+ parse("<?name content")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed XML: Unclosed processing instruction
+Line: 1
+Position: 14
+Last 80 unconsumed characters:
+content
+ DETAIL
+ end
+
+ def test_unclosed_no_content
+ exception = assert_raise(REXML::ParseException) do
+ parse("<?name")
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Malformed XML: Unclosed processing instruction
+Line: 1
+Position: 6
+Last 80 unconsumed characters:
+
+ DETAIL
+ end
+
+ def test_xml_declaration_not_at_document_start
+ exception = assert_raise(REXML::ParseException) do
+ parser = REXML::Parsers::BaseParser.new('<a><?xml version="1.0" ?></a>')
+ while parser.has_next?
+ parser.pull
+ end
+ end
+
+ assert_equal(<<~DETAIL.chomp, exception.to_s)
+ Malformed XML: XML declaration is not at the start
+ Line: 1
+ Position: 25
+ Last 80 unconsumed characters:
+
+ DETAIL
+ end
+ end
+
+ def test_comment
+ doc = parse(<<-XML)
+<?x y
+<!--?><?x -->?>
+<r/>
+ XML
+ assert_equal([["x", "y\n<!--"],
+ ["x", "-->"]],
+ [[doc.children[0].target, doc.children[0].content],
+ [doc.children[1].target, doc.children[1].content]])
+ end
+
+ def test_before_root
+ parser = REXML::Parsers::BaseParser.new('<?abc version="1.0" ?><a></a>')
+
+ events = {}
+ while parser.has_next?
+ event = parser.pull
+ events[event[0]] = event[1]
+ end
+
+ assert_equal("abc", events[:processing_instruction])
+ end
+
+ def test_after_root
+ parser = REXML::Parsers::BaseParser.new('<a></a><?abc version="1.0" ?>')
+
+ events = {}
+ while parser.has_next?
+ event = parser.pull
+ events[event[0]] = event[1]
+ end
+
+ assert_equal("abc", events[:processing_instruction])
+ end
+
+ def test_content_question
+ document = REXML::Document.new("<a><?name con?tent?></a>")
+ assert_equal("con?tent", document.root.children.first.content)
+ end
+
+ def test_linear_performance_gt
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new("<?xml version=\"1.0\" " + ">" * n + " ?>")
+ end
+ end
+
+ def test_linear_performance_tab
+ seq = [10000, 50000, 100000, 150000, 200000]
+ assert_linear_performance(seq, rehearsal: 10) do |n|
+ REXML::Document.new("<?name" + "\t" * n + "version=\"1.0\" > ?>")
+ end
+ end
+ end
+end
diff --git a/test/rexml/parse/test_text.rb b/test/rexml/parse/test_text.rb
new file mode 100644
index 0000000000..04f553ae8b
--- /dev/null
+++ b/test/rexml/parse/test_text.rb
@@ -0,0 +1,57 @@
+require "test/unit"
+require 'rexml/parsers/baseparser'
+
+module REXMLTests
+ class TestParseText < Test::Unit::TestCase
+ class TestInvalid < self
+ def test_before_root
+ exception = assert_raise(REXML::ParseException) do
+ parser = REXML::Parsers::BaseParser.new('b<a></a>')
+ while parser.has_next?
+ parser.pull
+ end
+ end
+
+ assert_equal(<<~DETAIL.chomp, exception.to_s)
+ Malformed XML: Content at the start of the document (got 'b')
+ Line: 1
+ Position: 4
+ Last 80 unconsumed characters:
+ <a>
+ DETAIL
+ end
+
+ def test_after_root
+ exception = assert_raise(REXML::ParseException) do
+ parser = REXML::Parsers::BaseParser.new('<a></a>c')
+ while parser.has_next?
+ parser.pull
+ end
+ end
+
+ assert_equal(<<~DETAIL.chomp, exception.to_s)
+ Malformed XML: Extra content at the end of the document (got 'c')
+ Line: 1
+ Position: 8
+ Last 80 unconsumed characters:
+
+ DETAIL
+ end
+ end
+
+ def test_whitespace_characters_after_root
+ parser = REXML::Parsers::BaseParser.new('<a>b</a> ')
+
+ events = []
+ while parser.has_next?
+ event = parser.pull
+ case event[0]
+ when :text
+ events << event[1]
+ end
+ end
+
+ assert_equal(["b"], events)
+ end
+ end
+end
diff --git a/test/rexml/parser/test_base_parser.rb b/test/rexml/parser/test_base_parser.rb
new file mode 100644
index 0000000000..6f213978c0
--- /dev/null
+++ b/test/rexml/parser/test_base_parser.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: false
+
+require 'rexml/parsers/baseparser'
+
+module REXMLTests
+ class BaseParserTester < Test::Unit::TestCase
+ def test_large_xml
+ large_text = "a" * 100_000
+ xml = <<-XML
+ <?xml version="1.0"?>
+ <root>
+ <child>#{large_text}</child>
+ <child>#{large_text}</child>
+ </root>
+ XML
+
+ parser = REXML::Parsers::BaseParser.new(xml)
+ while parser.has_next?
+ parser.pull
+ end
+
+ assert do
+ parser.position < xml.bytesize
+ end
+ end
+
+ def test_attribute_prefixed_by_xml
+ xml = <<-XML
+ <?xml version="1.0" encoding="UTF-8"?>
+ <!DOCTYPE html>
+ <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+ <head>
+ <title>XHTML Document</title>
+ </head>
+ <body>
+ <h1>XHTML Document</h1>
+ <p xml:lang="ja" lang="ja">For Japanese</p>
+ </body>
+ </html>
+ XML
+
+ parser = REXML::Parsers::BaseParser.new(xml)
+ 5.times {parser.pull}
+
+ html = parser.pull
+ assert_equal([:start_element,
+ "html",
+ {"xmlns" => "http://www.w3.org/1999/xhtml",
+ "xml:lang" => "en",
+ "lang" => "en"}],
+ html)
+
+ 15.times {parser.pull}
+
+ p = parser.pull
+ assert_equal([:start_element,
+ "p",
+ {"xml:lang" => "ja", "lang" => "ja"}],
+ p)
+ end
+ end
+end
diff --git a/test/rexml/parser/test_sax2.rb b/test/rexml/parser/test_sax2.rb
index 91d135f5f7..c254890744 100644
--- a/test/rexml/parser/test_sax2.rb
+++ b/test/rexml/parser/test_sax2.rb
@@ -4,200 +4,200 @@
require "rexml/sax2listener"
module REXMLTests
-class TestSAX2Parser < Test::Unit::TestCase
- class TestDocumentTypeDeclaration < self
- private
- def xml(internal_subset)
- <<-XML
+ class TestSAX2Parser < Test::Unit::TestCase
+ class TestDocumentTypeDeclaration < self
+ private
+ def xml(internal_subset)
+ <<-XML
<!DOCTYPE r SYSTEM "urn:x-henrikmartensson:test" [
#{internal_subset}
]>
<r/>
- XML
- end
+ XML
+ end
- class TestEntityDeclaration < self
- class Listener
- include REXML::SAX2Listener
- attr_reader :entity_declarations
- def initialize
- @entity_declarations = []
- end
+ class TestEntityDeclaration < self
+ class Listener
+ include REXML::SAX2Listener
+ attr_reader :entity_declarations
+ def initialize
+ @entity_declarations = []
+ end
- def entitydecl(declaration)
- super
- @entity_declarations << declaration
+ def entitydecl(declaration)
+ super
+ @entity_declarations << declaration
+ end
end
- end
- private
- def parse(internal_subset)
- listener = Listener.new
- parser = REXML::Parsers::SAX2Parser.new(xml(internal_subset))
- parser.listen(listener)
- parser.parse
- listener.entity_declarations
- end
+ private
+ def parse(internal_subset)
+ listener = Listener.new
+ parser = REXML::Parsers::SAX2Parser.new(xml(internal_subset))
+ parser.listen(listener)
+ parser.parse
+ listener.entity_declarations
+ end
- class TestGeneralEntity < self
- class TestValue < self
- def test_double_quote
- assert_equal([["name", "value"]], parse(<<-INTERNAL_SUBSET))
+ class TestGeneralEntity < self
+ class TestValue < self
+ def test_double_quote
+ assert_equal([["name", "value"]], parse(<<-INTERNAL_SUBSET))
<!ENTITY name "value">
- INTERNAL_SUBSET
- end
+ INTERNAL_SUBSET
+ end
- def test_single_quote
- assert_equal([["name", "value"]], parse(<<-INTERNAL_SUBSET))
+ def test_single_quote
+ assert_equal([["name", "value"]], parse(<<-INTERNAL_SUBSET))
<!ENTITY name 'value'>
- INTERNAL_SUBSET
+ INTERNAL_SUBSET
+ end
end
- end
- class TestExternlID < self
- class TestSystem < self
- def test_with_ndata
- declaration = [
- "name",
- "SYSTEM", "system-literal",
- "NDATA", "ndata-name",
- ]
- assert_equal([declaration],
- parse(<<-INTERNAL_SUBSET))
+ class TestExternlID < self
+ class TestSystem < self
+ def test_with_ndata
+ declaration = [
+ "name",
+ "SYSTEM", "system-literal",
+ "NDATA", "ndata-name",
+ ]
+ assert_equal([declaration],
+ parse(<<-INTERNAL_SUBSET))
<!ENTITY name SYSTEM "system-literal" NDATA ndata-name>
+ INTERNAL_SUBSET
+ end
+
+ def test_without_ndata
+ declaration = [
+ "name",
+ "SYSTEM", "system-literal",
+ ]
+ assert_equal([declaration],
+ parse(<<-INTERNAL_SUBSET))
+<!ENTITY name SYSTEM "system-literal">
+ INTERNAL_SUBSET
+ end
+ end
+
+ class TestPublic < self
+ def test_with_ndata
+ declaration = [
+ "name",
+ "PUBLIC", "public-literal", "system-literal",
+ "NDATA", "ndata-name",
+ ]
+ assert_equal([declaration],
+ parse(<<-INTERNAL_SUBSET))
+<!ENTITY name PUBLIC "public-literal" "system-literal" NDATA ndata-name>
+ INTERNAL_SUBSET
+ end
+
+ def test_without_ndata
+ declaration = [
+ "name",
+ "PUBLIC", "public-literal", "system-literal",
+ ]
+ assert_equal([declaration], parse(<<-INTERNAL_SUBSET))
+<!ENTITY name PUBLIC "public-literal" "system-literal">
+ INTERNAL_SUBSET
+ end
+ end
+ end
+ end
+
+ class TestParameterEntity < self
+ class TestValue < self
+ def test_double_quote
+ assert_equal([["%", "name", "value"]], parse(<<-INTERNAL_SUBSET))
+<!ENTITY % name "value">
INTERNAL_SUBSET
end
- def test_without_ndata
- declaration = [
- "name",
- "SYSTEM", "system-literal",
- ]
- assert_equal([declaration],
- parse(<<-INTERNAL_SUBSET))
-<!ENTITY name SYSTEM "system-literal">
+ def test_single_quote
+ assert_equal([["%", "name", "value"]], parse(<<-INTERNAL_SUBSET))
+<!ENTITY % name 'value'>
INTERNAL_SUBSET
end
end
- class TestPublic < self
- def test_with_ndata
+ class TestExternlID < self
+ def test_system
declaration = [
+ "%",
"name",
- "PUBLIC", "public-literal", "system-literal",
- "NDATA", "ndata-name",
+ "SYSTEM", "system-literal",
]
assert_equal([declaration],
- parse(<<-INTERNAL_SUBSET))
-<!ENTITY name PUBLIC "public-literal" "system-literal" NDATA ndata-name>
+ parse(<<-INTERNAL_SUBSET))
+<!ENTITY % name SYSTEM "system-literal">
INTERNAL_SUBSET
end
- def test_without_ndata
+ def test_public
declaration = [
+ "%",
"name",
"PUBLIC", "public-literal", "system-literal",
]
assert_equal([declaration], parse(<<-INTERNAL_SUBSET))
-<!ENTITY name PUBLIC "public-literal" "system-literal">
+<!ENTITY % name PUBLIC "public-literal" "system-literal">
INTERNAL_SUBSET
end
end
end
end
- class TestParameterEntity < self
- class TestValue < self
- def test_double_quote
- assert_equal([["%", "name", "value"]], parse(<<-INTERNAL_SUBSET))
-<!ENTITY % name "value">
- INTERNAL_SUBSET
+ class TestNotationDeclaration < self
+ class Listener
+ include REXML::SAX2Listener
+ attr_reader :notation_declarations
+ def initialize
+ @notation_declarations = []
end
- def test_single_quote
- assert_equal([["%", "name", "value"]], parse(<<-INTERNAL_SUBSET))
-<!ENTITY % name 'value'>
- INTERNAL_SUBSET
+ def notationdecl(*declaration)
+ super
+ @notation_declarations << declaration
end
end
+ private
+ def parse(internal_subset)
+ listener = Listener.new
+ parser = REXML::Parsers::SAX2Parser.new(xml(internal_subset))
+ parser.listen(listener)
+ parser.parse
+ listener.notation_declarations
+ end
+
class TestExternlID < self
def test_system
- declaration = [
- "%",
- "name",
- "SYSTEM", "system-literal",
- ]
+ declaration = ["name", "SYSTEM", nil, "system-literal"]
assert_equal([declaration],
- parse(<<-INTERNAL_SUBSET))
-<!ENTITY % name SYSTEM "system-literal">
+ parse(<<-INTERNAL_SUBSET))
+<!NOTATION name SYSTEM "system-literal">
INTERNAL_SUBSET
end
def test_public
- declaration = [
- "%",
- "name",
- "PUBLIC", "public-literal", "system-literal",
- ]
+ declaration = ["name", "PUBLIC", "public-literal", "system-literal"]
assert_equal([declaration], parse(<<-INTERNAL_SUBSET))
-<!ENTITY % name PUBLIC "public-literal" "system-literal">
+<!NOTATION name PUBLIC "public-literal" "system-literal">
INTERNAL_SUBSET
end
end
- end
- end
- class TestNotationDeclaration < self
- class Listener
- include REXML::SAX2Listener
- attr_reader :notation_declarations
- def initialize
- @notation_declarations = []
- end
-
- def notationdecl(*declaration)
- super
- @notation_declarations << declaration
- end
- end
-
- private
- def parse(internal_subset)
- listener = Listener.new
- parser = REXML::Parsers::SAX2Parser.new(xml(internal_subset))
- parser.listen(listener)
- parser.parse
- listener.notation_declarations
- end
-
- class TestExternlID < self
- def test_system
- declaration = ["name", "SYSTEM", nil, "system-literal"]
- assert_equal([declaration],
- parse(<<-INTERNAL_SUBSET))
-<!NOTATION name SYSTEM "system-literal">
- INTERNAL_SUBSET
- end
-
- def test_public
- declaration = ["name", "PUBLIC", "public-literal", "system-literal"]
- assert_equal([declaration], parse(<<-INTERNAL_SUBSET))
-<!NOTATION name PUBLIC "public-literal" "system-literal">
- INTERNAL_SUBSET
- end
- end
-
- class TestPublicID < self
- def test_literal
- declaration = ["name", "PUBLIC", "public-literal", nil]
- assert_equal([declaration],
- parse(<<-INTERNAL_SUBSET))
+ class TestPublicID < self
+ def test_literal
+ declaration = ["name", "PUBLIC", "public-literal", nil]
+ assert_equal([declaration],
+ parse(<<-INTERNAL_SUBSET))
<!NOTATION name PUBLIC "public-literal">
- INTERNAL_SUBSET
+ INTERNAL_SUBSET
+ end
end
end
end
end
end
-end
diff --git a/test/rexml/parser/test_tree.rb b/test/rexml/parser/test_tree.rb
index 8a5d9d1223..315be9c23f 100644
--- a/test/rexml/parser/test_tree.rb
+++ b/test/rexml/parser/test_tree.rb
@@ -4,40 +4,39 @@
require "rexml/parsers/treeparser"
module REXMLTests
-class TestTreeParser < Test::Unit::TestCase
- class TestInvalid < self
- def test_unmatched_close_tag
- xml = "<root></not-root>"
- exception = assert_raise(REXML::ParseException) do
- parse(xml)
- end
- assert_equal(<<-MESSAGE, exception.to_s)
+ class TestTreeParser < Test::Unit::TestCase
+ private def parse(xml)
+ document = REXML::Document.new
+ parser = REXML::Parsers::TreeParser.new(xml, document)
+ parser.parse
+ end
+
+ class TestInvalid < self
+ def test_unmatched_close_tag
+ xml = "<root></not-root>"
+ exception = assert_raise(REXML::ParseException) do
+ parse(xml)
+ end
+ assert_equal(<<-MESSAGE, exception.to_s)
Missing end tag for 'root' (got 'not-root')
Line: 1
Position: #{xml.bytesize}
Last 80 unconsumed characters:
- MESSAGE
- end
-
- def test_no_close_tag
- xml = "<root>"
- exception = assert_raise(REXML::ParseException) do
- parse(xml)
+ MESSAGE
end
- assert_equal(<<-MESSAGE, exception.to_s)
-No close tag for /root
+
+ def test_no_close_tag
+ xml = "<root>"
+ exception = assert_raise(REXML::ParseException) do
+ parse(xml)
+ end
+ assert_equal(<<-MESSAGE, exception.to_s)
+Missing end tag for '/root'
Line: 1
Position: #{xml.bytesize}
Last 80 unconsumed characters:
- MESSAGE
- end
-
- private
- def parse(xml)
- document = REXML::Document.new
- parser = REXML::Parsers::TreeParser.new(xml, document)
- parser.parse
+ MESSAGE
+ end
end
end
end
-end
diff --git a/test/rexml/parser/test_ultra_light.rb b/test/rexml/parser/test_ultra_light.rb
index cb6ee5a8ab..d1364d6a99 100644
--- a/test/rexml/parser/test_ultra_light.rb
+++ b/test/rexml/parser/test_ultra_light.rb
@@ -3,67 +3,66 @@
require "rexml/parsers/ultralightparser"
module REXMLTests
-class TestUltraLightParser < Test::Unit::TestCase
- class TestDocumentTypeDeclaration < self
- def test_entity_declaration
- assert_equal([
- [
- :start_doctype,
- :parent,
- "root",
- "SYSTEM",
- "urn:x-test",
- nil,
- [:entitydecl, "name", "value"]
+ class TestUltraLightParser < Test::Unit::TestCase
+ class TestDocumentTypeDeclaration < self
+ def test_entity_declaration
+ assert_equal([
+ [
+ :start_doctype,
+ :parent,
+ "root",
+ "SYSTEM",
+ "urn:x-test",
+ nil,
+ [:entitydecl, "name", "value"]
+ ],
+ [:start_element, :parent, "root", {}],
],
- [:start_element, :parent, "root", {}],
- [:text, "\n"],
- ],
- parse(<<-INTERNAL_SUBSET))
+ parse(<<-INTERNAL_SUBSET))
<!ENTITY name "value">
- INTERNAL_SUBSET
- end
+ INTERNAL_SUBSET
+ end
- private
- def xml(internal_subset)
- <<-XML
+ private
+ def xml(internal_subset)
+ <<-XML
<!DOCTYPE root SYSTEM "urn:x-test" [
#{internal_subset}
]>
<root/>
- XML
- end
+ XML
+ end
- def parse(internal_subset)
- parser = REXML::Parsers::UltraLightParser.new(xml(internal_subset))
- normalize(parser.parse)
- end
+ def parse(internal_subset)
+ parser = REXML::Parsers::UltraLightParser.new(xml(internal_subset))
+ normalize(parser.parse)
+ end
- def normalize(root)
- root.collect do |child|
- normalize_child(child)
+ def normalize(root)
+ root.collect do |child|
+ normalize_child(child)
+ end
end
- end
- def normalize_child(child)
- tag = child.first
- case tag
- when :start_doctype
- normalized_parent = :parent
- normalized_doctype = child.dup
- normalized_doctype[1] = normalized_parent
- normalized_doctype
- when :start_element
- tag, parent, name, attributes, *children = child
- normalized_parent = :parent
- normalized_children = children.collect do |sub_child|
- normalize_child(sub_child)
+ def normalize_child(child)
+ tag = child.first
+ case tag
+ when :start_doctype
+ normalized_parent = :parent
+ normalized_doctype = child.dup
+ normalized_doctype[1] = normalized_parent
+ normalized_doctype
+ when :start_element
+ tag, _parent, name, attributes, *children = child
+ normalized_parent = :parent
+ normalized_children = children.collect do |sub_child|
+ normalize_child(sub_child)
+ end
+ [tag, normalized_parent, name, attributes, *normalized_children]
+ else
+ child
end
- [tag, normalized_parent, name, attributes, *normalized_children]
- else
- child
end
end
end
end
-end
diff --git a/test/rexml/parser/test_xpath.rb b/test/rexml/parser/test_xpath.rb
new file mode 100644
index 0000000000..360b9b793a
--- /dev/null
+++ b/test/rexml/parser/test_xpath.rb
@@ -0,0 +1,127 @@
+# frozen_string_literal: false
+
+require "test/unit"
+require "rexml/parsers/xpathparser"
+
+module REXMLTests
+ class TestXPathParser < Test::Unit::TestCase
+ def self.sub_test_case(name, &block)
+ parent_test_case = self
+ sub_test_case = Class.new(self) do
+ singleton_class = class << self; self; end
+ singleton_class.__send__(:define_method, :name) do
+ [parent_test_case.name, name].compact.join("::")
+ end
+ end
+ sub_test_case.class_eval(&block)
+ sub_test_case
+ end
+
+ sub_test_case("#abbreviate") do
+ def abbreviate(xpath)
+ parser = REXML::Parsers::XPathParser.new
+ parser.abbreviate(xpath)
+ end
+
+ def test_document
+ assert_equal("/",
+ abbreviate("/"))
+ end
+
+ def test_descendant_or_self_only
+ assert_equal("//",
+ abbreviate("/descendant-or-self::node()/"))
+ end
+
+ def test_descendant_or_self_absolute
+ assert_equal("//a/b",
+ abbreviate("/descendant-or-self::node()/a/b"))
+ end
+
+ def test_descendant_or_self_relative
+ assert_equal("a//b",
+ abbreviate("a/descendant-or-self::node()/b"))
+ end
+
+ def test_descendant_or_self_not_node
+ assert_equal("/descendant-or-self::text()",
+ abbreviate("/descendant-or-self::text()"))
+ end
+
+ def test_self_absolute
+ assert_equal("/a/./b",
+ abbreviate("/a/self::node()/b"))
+ end
+
+ def test_self_relative
+ assert_equal("a/./b",
+ abbreviate("a/self::node()/b"))
+ end
+
+ def test_self_not_node
+ assert_equal("/self::text()",
+ abbreviate("/self::text()"))
+ end
+
+ def test_parent_absolute
+ assert_equal("/a/../b",
+ abbreviate("/a/parent::node()/b"))
+ end
+
+ def test_parent_relative
+ assert_equal("a/../b",
+ abbreviate("a/parent::node()/b"))
+ end
+
+ def test_parent_not_node
+ assert_equal("/a/parent::text()",
+ abbreviate("/a/parent::text()"))
+ end
+
+ def test_any_absolute
+ assert_equal("/*/a",
+ abbreviate("/*/a"))
+ end
+
+ def test_any_relative
+ assert_equal("a/*/b",
+ abbreviate("a/*/b"))
+ end
+
+ def test_following_sibling_absolute
+ assert_equal("/following-sibling::a/b",
+ abbreviate("/following-sibling::a/b"))
+ end
+
+ def test_following_sibling_relative
+ assert_equal("a/following-sibling::b/c",
+ abbreviate("a/following-sibling::b/c"))
+ end
+
+ def test_predicate_index
+ assert_equal("a[5]/b",
+ abbreviate("a[5]/b"))
+ end
+
+ def test_attribute_relative
+ assert_equal("a/@b",
+ abbreviate("a/attribute::b"))
+ end
+
+ def test_filter_attribute
+ assert_equal("a/b[@i = 1]/c",
+ abbreviate("a/b[attribute::i=1]/c"))
+ end
+
+ def test_filter_string_single_quote
+ assert_equal("a/b[@name = \"single ' quote\"]/c",
+ abbreviate("a/b[attribute::name=\"single ' quote\"]/c"))
+ end
+
+ def test_filter_string_double_quote
+ assert_equal("a/b[@name = 'double \" quote']/c",
+ abbreviate("a/b[attribute::name='double \" quote']/c"))
+ end
+ end
+ end
+end
diff --git a/test/rexml/run.rb b/test/rexml/run.rb
new file mode 100755
index 0000000000..089318b014
--- /dev/null
+++ b/test/rexml/run.rb
@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = true
+
+base_dir = File.dirname(File.expand_path(__dir__))
+lib_dir = File.join(base_dir, "lib")
+test_dir = File.join(base_dir, "test")
+
+$LOAD_PATH.unshift(lib_dir)
+
+require_relative "helper"
+
+exit(Test::Unit::AutoRunner.run(true, test_dir))
diff --git a/test/rexml/test_attribute.rb b/test/rexml/test_attribute.rb
new file mode 100644
index 0000000000..b66e462d4a
--- /dev/null
+++ b/test/rexml/test_attribute.rb
@@ -0,0 +1,12 @@
+module REXMLTests
+ class AttributeTest < Test::Unit::TestCase
+ def test_empty_prefix
+ error = assert_raise(ArgumentError) do
+ REXML::Attribute.new(":x")
+ end
+ assert_equal("name must be " +
+ "\#{PREFIX}:\#{LOCAL_NAME} or \#{LOCAL_NAME}: <\":x\">",
+ error.message)
+ end
+ end
+end
diff --git a/test/rexml/test_attributes.rb b/test/rexml/test_attributes.rb
index d6f566bdf8..09fde44224 100644
--- a/test/rexml/test_attributes.rb
+++ b/test/rexml/test_attributes.rb
@@ -1,6 +1,4 @@
# frozen_string_literal: false
-require 'test/unit/testcase'
-require 'rexml/document'
module REXMLTests
class AttributesTester < Test::Unit::TestCase
@@ -180,18 +178,27 @@ def test_amp_and_lf_attributes
attr_test('name','value with LF 
 & ampersand')
end
- def test_quoting
+ def test_quote_root
d = Document.new(%q{<a x='1' y="2"/>})
assert_equal( %q{<a x='1' y='2'/>}, d.to_s )
d.root.context[:attribute_quote] = :quote
assert_equal( %q{<a x="1" y="2"/>}, d.to_s )
+ end
+ def test_quote_sub_element
d = Document.new(%q{<a x='1' y="2"><b z='3'/></a>})
assert_equal( %q{<a x='1' y='2'><b z='3'/></a>}, d.to_s )
d.root.context[:attribute_quote] = :quote
assert_equal( %q{<a x="1" y="2"><b z="3"/></a>}, d.to_s )
end
+ def test_quote_to_s_value
+ doc = Document.new(%q{<root a="'"/>}, {attribute_quote: :quote})
+ assert_equal(%q{<root a="'"/>}, doc.to_s)
+ assert_equal("'", doc.root.attribute("a").value)
+ assert_equal(%q{<root a="'"/>}, doc.to_s)
+ end
+
def test_ticket_127
doc = Document.new
doc.add_element 'a', { 'v' => 'x & y' }
diff --git a/test/rexml/test_attributes_mixin.rb b/test/rexml/test_attributes_mixin.rb
index 3a9f54eefd..2b9108cbc6 100644
--- a/test/rexml/test_attributes_mixin.rb
+++ b/test/rexml/test_attributes_mixin.rb
@@ -1,6 +1,4 @@
# frozen_string_literal: false
-require 'test/unit'
-require 'rexml/document'
module REXMLTests
class TestAttributes < Test::Unit::TestCase
diff --git a/test/rexml/test_comment.rb b/test/rexml/test_comment.rb
index 0af2f5ca76..f6f4d8099d 100644
--- a/test/rexml/test_comment.rb
+++ b/test/rexml/test_comment.rb
@@ -1,7 +1,4 @@
# frozen_string_literal: false
-require "test/unit/testcase"
-
-require 'rexml/document'
module REXMLTests
class CommentTester < Test::Unit::TestCase
diff --git a/test/rexml/test_contrib.rb b/test/rexml/test_contrib.rb
index 8462b3c23f..c16c72f2a6 100644
--- a/test/rexml/test_contrib.rb
+++ b/test/rexml/test_contrib.rb
@@ -1,15 +1,14 @@
# coding: binary
# frozen_string_literal: false
-require_relative "rexml_test_utils"
-
-require "rexml/document"
require "rexml/parseexception"
require "rexml/formatters/default"
+require_relative "helper"
+
module REXMLTests
class ContribTester < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
include REXML
XML_STRING_01 = <<DELIMITER
@@ -73,6 +72,7 @@ def test_bad_doctype_Tobias
>
]
>
+ <svg/>
EOF
doc = REXML::Document.new source
doc.write(out="")
@@ -82,7 +82,7 @@ def test_bad_doctype_Tobias
# Peter Verhage
def test_namespace_Peter
- source = <<-EOF
+ source = <<~EOF
<?xml version="1.0"?>
<config:myprog-config xmlns:config="http://someurl/program/version">
<!-- main options -->
@@ -379,7 +379,7 @@ def test_various_xpath
end
def test_entities_Holden_Glova
- document = <<-EOL
+ document = <<~EOL
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE rubynet [
<!ENTITY rbconfig.MAJOR "1">
diff --git a/test/rexml/test_core.rb b/test/rexml/test_core.rb
index ee5438d5e5..eed9cca2c0 100644
--- a/test/rexml/test_core.rb
+++ b/test/rexml/test_core.rb
@@ -1,8 +1,6 @@
-# coding: utf-8
+# -*- coding: utf-8 -*-
# frozen_string_literal: false
-require_relative "rexml_test_utils"
-
require "rexml/document"
require "rexml/parseexception"
require "rexml/output"
@@ -11,13 +9,14 @@
require "rexml/undefinednamespaceexception"
require_relative "listener"
+require_relative "helper"
module REXMLTests
class Tester < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
include REXML
def setup
- @xsa_source = <<-EOL
+ @xsa_source = <<~EOL
<?xml version="1.0"?>
<?xsl stylesheet="blah.xsl"?>
<!-- The first line tests the XMLDecl, the second tests PI.
@@ -91,7 +90,7 @@ def test_attribute
# Bryan Murphy <murphybryanp@yahoo.com>
text = "this is a {target[@name='test']/@value} test"
- source = <<-EOL
+ source = <<~EOL
<?xml version="1.0"?>
<doc search="#{text}"/>
EOL
@@ -116,6 +115,72 @@ def test_attribute
name4='test4'/>).join(' '), e.to_s
end
+ def test_attribute_duplicated
+ # https://www.w3.org/TR/xml-names/#uniqAttrs
+ message = <<-MESSAGE.chomp
+Duplicate attribute "a"
+Line: 2
+Position: 24
+Last 80 unconsumed characters:
+/>
+ MESSAGE
+ assert_raise(REXML::ParseException.new(message)) do
+ Document.new(<<-XML)
+<x>
+ <bad a="1" a="2"/>
+</x>
+ XML
+ end
+ end
+
+ def test_attribute_namespace_conflict
+ # https://www.w3.org/TR/xml-names/#uniqAttrs
+ message = <<-MESSAGE.chomp
+Namespace conflict in adding attribute "a": Prefix "n1" = "http://www.w3.org" and prefix "n2" = "http://www.w3.org"
+Line: 4
+Position: 140
+Last 80 unconsumed characters:
+/>
+ MESSAGE
+ assert_raise(REXML::ParseException.new(message)) do
+ Document.new(<<-XML)
+<!-- http://www.w3.org is bound to n1 and n2 -->
+<x xmlns:n1="http://www.w3.org"
+ xmlns:n2="http://www.w3.org">
+ <bad n1:a="1" n2:a="2"/>
+</x>
+ XML
+ end
+ end
+
+ def test_attribute_default_namespace
+ # https://www.w3.org/TR/xml-names/#uniqAttrs
+ document = Document.new(<<-XML)
+<!-- http://www.w3.org is bound to n1 and is the default -->
+<x xmlns:n1="http://www.w3.org"
+ xmlns="http://www.w3.org" >
+ <good a="1" b="2" />
+ <good a="1" n1:a="2" />
+</x>
+ XML
+ attributes = document.root.elements.collect do |element|
+ element.attributes.each_attribute.collect do |attribute|
+ [attribute.prefix, attribute.namespace, attribute.name]
+ end
+ end
+ assert_equal([
+ [
+ ["", "", "a"],
+ ["", "", "b"],
+ ],
+ [
+ ["", "", "a"],
+ ["n1", "http://www.w3.org", "a"],
+ ],
+ ],
+ attributes)
+ end
+
def test_cdata
test = "The quick brown fox jumped
& < & < \" '
@@ -681,7 +746,7 @@ def test_iso_8859_1_output_function
koln_iso_8859_1 = "K\xF6ln"
koln_utf8 = "K\xc3\xb6ln"
source = Source.new( koln_iso_8859_1, 'iso-8859-1' )
- results = source.scan(/.*/)[0]
+ results = source.match(/.*/)[0]
koln_utf8.force_encoding('UTF-8') if koln_utf8.respond_to?(:force_encoding)
assert_equal koln_utf8, results
output << results
@@ -779,7 +844,7 @@ def test_deep_clone
end
def test_whitespace_before_root
- a = <<EOL
+ a = <<EOL.chomp
<?xml version='1.0'?>
<blo>
<wak>
@@ -823,7 +888,7 @@ def test_attlist_decl
assert_equal 'two', doc.root.elements[1].namespace
assert_equal 'foo', doc.root.namespace
- doc = Document.new <<-EOL
+ doc = Document.new <<~EOL
<?xml version="1.0"?>
<!DOCTYPE schema SYSTEM "XMLSchema.dtd" [
<!ENTITY % p ''>
@@ -877,18 +942,18 @@ def test_ticket_51
EOL
# The most common case. People not caring about the namespaces much.
- assert_equal( "XY", XPath.match( doc, "/test/a/text()" ).join )
- assert_equal( "XY", XPath.match( doc, "/test/x:a/text()" ).join )
+ assert_equal( "XY", XPath.match( doc, "/*:test/*:a/text()" ).join )
+ assert_equal( "XY", XPath.match( doc, "/*:test/x:a/text()" ).join )
# Surprising? I don't think so, if you believe my definition of the "common case"
- assert_equal( "XYZ", XPath.match( doc, "//a/text()" ).join )
+ assert_equal( "XYZ", XPath.match( doc, "//*:a/text()" ).join )
# These are the uncommon cases. Namespaces are actually important, so we define our own
# mappings, and pass them in.
assert_equal( "XY", XPath.match( doc, "/f:test/f:a/text()", { "f" => "1" } ).join )
# The namespaces are defined, and override the original mappings
- assert_equal( "", XPath.match( doc, "/test/a/text()", { "f" => "1" } ).join )
+ assert_equal( "XY", XPath.match( doc, "/*:test/*:a/text()", { "f" => "1" } ).join )
assert_equal( "", XPath.match( doc, "/x:test/x:a/text()", { "f" => "1" } ).join )
- assert_equal( "", XPath.match( doc, "//a/text()", { "f" => "1" } ).join )
+ assert_equal( "XYZ", XPath.match( doc, "//*:a/text()", { "f" => "1" } ).join )
end
def test_processing_instruction
@@ -900,7 +965,7 @@ def test_processing_instruction
end
def test_oses_with_bad_EOLs
- Document.new("\n\n\n<?xml version='1.0'?>\n\n\n<a/>\n\n")
+ Document.new("<?xml version='1.0'?>\n\n\n<a/>\n\n")
end
# Contributed (with patch to fix bug) by Kouhei
@@ -927,7 +992,7 @@ def test_0xD_in_preface
end
def test_hyphens_in_doctype
- doc = REXML::Document.new <<-EOQ
+ doc = REXML::Document.new <<~EOQ
<?xml version="1.0"?>
<!DOCTYPE a-b-c>
<a-b-c>
@@ -1043,7 +1108,7 @@ def test_null_element_name
def test_text_raw
# From the REXML tutorial
# (http://www.germane-software.com/software/rexml/test/data/tutorial.html)
- doc = Document.new <<-EOL
+ doc = Document.new <<~EOL
<?xml version="1.0"?>
<!DOCTYPE schema SYSTEM "XMLSchema.dtd" [
<!ENTITY % s 'Sean'>
@@ -1277,11 +1342,26 @@ def test_ticket_21
exception = assert_raise(ParseException) do
Document.new(src)
end
- assert_equal(<<-DETAIL, exception.to_s)
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
Missing attribute value start quote: <bar>
Line: 1
Position: 16
Last 80 unconsumed characters:
+value/>
+ DETAIL
+ end
+
+ def test_parse_exception_on_missing_attribute_end_quote
+ src = '<foo bar="value/>'
+ exception = assert_raise(ParseException) do
+ Document.new(src)
+ end
+ assert_equal(<<-DETAIL.chomp, exception.to_s)
+Missing attribute value end quote: <bar>: <">
+Line: 1
+Position: 17
+Last 80 unconsumed characters:
+value/>
DETAIL
end
@@ -1377,7 +1457,7 @@ def test_ticket_91
d.root.add_element( "bah" )
p=REXML::Formatters::Pretty.new(2)
p.compact = true # Don't add whitespace to text nodes unless necessary
- p.write(d,out="")
+ p.write(d,out=+"")
assert_equal( expected, out )
end
@@ -1391,8 +1471,8 @@ def test_ticket_95
def test_ticket_102
doc = REXML::Document.new '<doc xmlns="ns"><item name="foo"/></doc>'
- assert_equal( "foo", doc.root.elements["item"].attribute("name","ns").to_s )
- assert_equal( "item", doc.root.elements["item[@name='foo']"].name )
+ assert_equal( "foo", doc.root.elements["*:item"].attribute("name","ns").to_s )
+ assert_equal( "item", doc.root.elements["*:item[@name='foo']"].name )
end
def test_ticket_14
@@ -1421,11 +1501,11 @@ def test_ticket_121
doc = REXML::Document.new(
'<doc xmlns="ns" xmlns:phantom="ns"><item name="foo">text</item></doc>'
)
- assert_equal 'text', doc.text( "/doc/item[@name='foo']" )
+ assert_equal 'text', doc.text( "/*:doc/*:item[@name='foo']" )
assert_equal "name='foo'",
- doc.root.elements["item"].attribute("name", "ns").inspect
+ doc.root.elements["*:item"].attribute("name", "ns").inspect
assert_equal "<item name='foo'>text</item>",
- doc.root.elements["item[@name='foo']"].to_s
+ doc.root.elements["*:item[@name='foo']"].to_s
end
def test_ticket_135
@@ -1453,8 +1533,10 @@ def test_ticket_138
"" => attribute("version", "1.0"),
},
}
- assert_equal(expected, doc.root.attributes)
- assert_equal(expected, REXML::Document.new(doc.root.to_s).root.attributes)
+ assert_equal(expected,
+ doc.root.attributes.to_h)
+ assert_equal(expected,
+ REXML::Document.new(doc.root.to_s).root.attributes.to_h)
end
def test_empty_doc
diff --git a/test/rexml/test_doctype.rb b/test/rexml/test_doctype.rb
index d728cba606..b20d30ae2f 100644
--- a/test/rexml/test_doctype.rb
+++ b/test/rexml/test_doctype.rb
@@ -1,6 +1,4 @@
# frozen_string_literal: false
-require 'test/unit'
-require 'rexml/document'
module REXMLTests
class TestDocTypeAccessor < Test::Unit::TestCase
@@ -41,6 +39,12 @@ def test_to_s
@doc_type_public_system.to_s)
end
+ def test_to_s_apostrophe
+ @doc_type_public_system.parent.context[:prologue_quote] = :apostrophe
+ assert_equal("<!DOCTYPE root PUBLIC '#{@pubid}' '#{@sysid}'>",
+ @doc_type_public_system.to_s)
+ end
+
def test_system
assert_equal([
@sysid,
@@ -82,6 +86,35 @@ def test_to_s
assert_equal("<!DOCTYPE root SYSTEM \"root.dtd\">",
doctype.to_s)
end
+
+ def test_to_s_apostrophe
+ doctype = REXML::DocType.new(["root", "SYSTEM", nil, "root.dtd"])
+ doc = REXML::Document.new
+ doc << doctype
+ doctype.parent.context[:prologue_quote] = :apostrophe
+ assert_equal("<!DOCTYPE root SYSTEM 'root.dtd'>",
+ doctype.to_s)
+ end
+
+ def test_to_s_single_quote_apostrophe
+ doctype = REXML::DocType.new(["root", "SYSTEM", nil, "root'.dtd"])
+ doc = REXML::Document.new
+ doc << doctype
+ # This isn't used.
+ doctype.parent.context[:prologue_quote] = :apostrophe
+ assert_equal("<!DOCTYPE root SYSTEM \"root'.dtd\">",
+ doctype.to_s)
+ end
+
+ def test_to_s_double_quote
+ doctype = REXML::DocType.new(["root", "SYSTEM", nil, "root\".dtd"])
+ doc = REXML::Document.new
+ doc << doctype
+ # This isn't used.
+ doctype.parent.context[:prologue_quote] = :apostrophe
+ assert_equal("<!DOCTYPE root SYSTEM 'root\".dtd'>",
+ doctype.to_s)
+ end
end
end
@@ -92,6 +125,25 @@ def test_to_s
assert_equal("<!DOCTYPE root PUBLIC \"pub\" \"root.dtd\">",
doctype.to_s)
end
+
+ def test_to_s_apostrophe
+ doctype = REXML::DocType.new(["root", "PUBLIC", "pub", "root.dtd"])
+ doc = REXML::Document.new
+ doc << doctype
+ doctype.parent.context[:prologue_quote] = :apostrophe
+ assert_equal("<!DOCTYPE root PUBLIC 'pub' 'root.dtd'>",
+ doctype.to_s)
+ end
+
+ def test_to_s_apostrophe_include_apostrophe
+ doctype = REXML::DocType.new(["root", "PUBLIC", "pub'", "root.dtd"])
+ doc = REXML::Document.new
+ doc << doctype
+ # This isn't used.
+ doctype.parent.context[:prologue_quote] = :apostrophe
+ assert_equal("<!DOCTYPE root PUBLIC \"pub'\" 'root.dtd'>",
+ doctype.to_s)
+ end
end
class TestSystemLiteral < self
@@ -101,6 +153,25 @@ def test_to_s
doctype.to_s)
end
+ def test_to_s_apostrophe
+ doctype = REXML::DocType.new(["root", "PUBLIC", "pub", "root.dtd"])
+ doc = REXML::Document.new
+ doc << doctype
+ doctype.parent.context[:prologue_quote] = :apostrophe
+ assert_equal("<!DOCTYPE root PUBLIC 'pub' 'root.dtd'>",
+ doctype.to_s)
+ end
+
+ def test_to_s_apostrophe_include_apostrophe
+ doctype = REXML::DocType.new(["root", "PUBLIC", "pub", "root'.dtd"])
+ doc = REXML::Document.new
+ doc << doctype
+ # This isn't used.
+ doctype.parent.context[:prologue_quote] = :apostrophe
+ assert_equal("<!DOCTYPE root PUBLIC 'pub' \"root'.dtd\">",
+ doctype.to_s)
+ end
+
def test_to_s_double_quote
doctype = REXML::DocType.new(["root", "PUBLIC", "pub", "root\".dtd"])
assert_equal("<!DOCTYPE root PUBLIC \"pub\" 'root\".dtd'>",
@@ -143,6 +214,62 @@ def test_to_s_system_literal_include_double_quote
decl(@id, "system\"literal").to_s)
end
+ def test_to_s_apostrophe
+ document = REXML::Document.new(<<-XML)
+ <!DOCTYPE root SYSTEM "urn:x-test:sysid" [
+ #{decl(@id, @uri).to_s}
+ ]>
+ <root/>
+ XML
+ document.context[:prologue_quote] = :apostrophe
+ notation = document.doctype.notations[0]
+ assert_equal("<!NOTATION #{@name} PUBLIC '#{@id}' '#{@uri}'>",
+ notation.to_s)
+ end
+
+ def test_to_s_apostrophe_pubid_literal_include_apostrophe
+ document = REXML::Document.new(<<-XML)
+ <!DOCTYPE root SYSTEM "urn:x-test:sysid" [
+ #{decl("#{@id}'", @uri).to_s}
+ ]>
+ <root/>
+ XML
+ # This isn't used for PubidLiteral because PubidChar includes '.
+ document.context[:prologue_quote] = :apostrophe
+ notation = document.doctype.notations[0]
+ assert_equal("<!NOTATION #{@name} PUBLIC \"#{@id}'\" '#{@uri}'>",
+ notation.to_s)
+ end
+
+ def test_to_s_apostrophe_system_literal_include_apostrophe
+ document = REXML::Document.new(<<-XML)
+ <!DOCTYPE root SYSTEM "urn:x-test:sysid" [
+ #{decl(@id, "system'literal").to_s}
+ ]>
+ <root/>
+ XML
+ # This isn't used for SystemLiteral because SystemLiteral includes '.
+ document.context[:prologue_quote] = :apostrophe
+ notation = document.doctype.notations[0]
+ assert_equal("<!NOTATION #{@name} PUBLIC '#{@id}' \"system'literal\">",
+ notation.to_s)
+ end
+
+ def test_to_s_apostrophe_system_literal_include_double_quote
+ document = REXML::Document.new(<<-XML)
+ <!DOCTYPE root SYSTEM "urn:x-test:sysid" [
+ #{decl(@id, "system\"literal").to_s}
+ ]>
+ <root/>
+ XML
+ # This isn't used for SystemLiteral because SystemLiteral includes ".
+ # But quoted by ' because SystemLiteral includes ".
+ document.context[:prologue_quote] = :apostrophe
+ notation = document.doctype.notations[0]
+ assert_equal("<!NOTATION #{@name} PUBLIC '#{@id}' 'system\"literal'>",
+ notation.to_s)
+ end
+
private
def decl(id, uri)
REXML::NotationDecl.new(@name, "PUBLIC", id, uri)
@@ -170,6 +297,48 @@ def test_to_s_include_double_quote
decl("#{@id}\"").to_s)
end
+ def test_to_s_apostrophe
+ document = REXML::Document.new(<<-XML)
+ <!DOCTYPE root SYSTEM "urn:x-test:sysid" [
+ #{decl(@id).to_s}
+ ]>
+ <root/>
+ XML
+ document.context[:prologue_quote] = :apostrophe
+ notation = document.doctype.notations[0]
+ assert_equal("<!NOTATION #{@name} SYSTEM '#{@id}'>",
+ notation.to_s)
+ end
+
+ def test_to_s_apostrophe_include_apostrophe
+ document = REXML::Document.new(<<-XML)
+ <!DOCTYPE root SYSTEM "urn:x-test:sysid" [
+ #{decl("#{@id}'").to_s}
+ ]>
+ <root/>
+ XML
+ # This isn't used for SystemLiteral because SystemLiteral includes '.
+ document.context[:prologue_quote] = :apostrophe
+ notation = document.doctype.notations[0]
+ assert_equal("<!NOTATION #{@name} SYSTEM \"#{@id}'\">",
+ notation.to_s)
+ end
+
+ def test_to_s_apostrophe_include_double_quote
+ document = REXML::Document.new(<<-XML)
+ <!DOCTYPE root SYSTEM "urn:x-test:sysid" [
+ #{decl("#{@id}\"").to_s}
+ ]>
+ <root/>
+ XML
+ # This isn't used for SystemLiteral because SystemLiteral includes ".
+ # But quoted by ' because SystemLiteral includes ".
+ document.context[:prologue_quote] = :apostrophe
+ notation = document.doctype.notations[0]
+ assert_equal("<!NOTATION #{@name} SYSTEM '#{@id}\"'>",
+ notation.to_s)
+ end
+
private
def decl(id)
REXML::NotationDecl.new(@name, "SYSTEM", nil, id)
diff --git a/test/rexml/test_document.rb b/test/rexml/test_document.rb
index c0faae4ae0..cda4354f31 100644
--- a/test/rexml/test_document.rb
+++ b/test/rexml/test_document.rb
@@ -1,13 +1,10 @@
# -*- coding: utf-8 -*-
# frozen_string_literal: false
-require "rexml/document"
-require "test/unit"
-
module REXMLTests
class TestDocument < Test::Unit::TestCase
def test_version_attributes_to_s
- doc = REXML::Document.new(<<-eoxml)
+ doc = REXML::Document.new(<<~eoxml)
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg id="svg2"
xmlns:sodipodi="foo"
@@ -34,17 +31,9 @@ def test_new
end
class EntityExpansionLimitTest < Test::Unit::TestCase
- def setup
- @default_entity_expansion_limit = REXML::Security.entity_expansion_limit
- end
-
- def teardown
- REXML::Security.entity_expansion_limit = @default_entity_expansion_limit
- end
-
class GeneralEntityTest < self
def test_have_value
- xml = <<EOF
+ xml = <<XML
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE member [
<!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
@@ -58,23 +47,23 @@ def test_have_value
<member>
&a;
</member>
-EOF
+XML
doc = REXML::Document.new(xml)
- assert_raise(RuntimeError) do
+ assert_raise(RuntimeError.new("entity expansion has grown too large")) do
doc.root.children.first.value
end
- REXML::Security.entity_expansion_limit = 100
- assert_equal(100, REXML::Security.entity_expansion_limit)
+
doc = REXML::Document.new(xml)
- assert_raise(RuntimeError) do
+ doc.entity_expansion_limit = 100
+ assert_raise(RuntimeError.new("number of entity expansions exceeded, processing aborted.")) do
doc.root.children.first.value
end
assert_equal(101, doc.entity_expansion_count)
end
def test_empty_value
- xml = <<EOF
+ xml = <<XML
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE member [
<!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
@@ -88,23 +77,23 @@ def test_empty_value
<member>
&a;
</member>
-EOF
+XML
doc = REXML::Document.new(xml)
- assert_raise(RuntimeError) do
+ assert_raise(RuntimeError.new("number of entity expansions exceeded, processing aborted.")) do
doc.root.children.first.value
end
- REXML::Security.entity_expansion_limit = 100
- assert_equal(100, REXML::Security.entity_expansion_limit)
+
doc = REXML::Document.new(xml)
- assert_raise(RuntimeError) do
+ doc.entity_expansion_limit = 100
+ assert_raise(RuntimeError.new("number of entity expansions exceeded, processing aborted.")) do
doc.root.children.first.value
end
assert_equal(101, doc.entity_expansion_count)
end
def test_with_default_entity
- xml = <<EOF
+ xml = <<XML
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE member [
<!ENTITY a "a">
@@ -115,68 +104,35 @@ def test_with_default_entity
&a2;
<
</member>
-EOF
+XML
- REXML::Security.entity_expansion_limit = 4
doc = REXML::Document.new(xml)
+ doc.entity_expansion_limit = 4
assert_equal("\na\na a\n<\n", doc.root.children.first.value)
- REXML::Security.entity_expansion_limit = 3
+
doc = REXML::Document.new(xml)
- assert_raise(RuntimeError) do
+ doc.entity_expansion_limit = 3
+ assert_raise(RuntimeError.new("number of entity expansions exceeded, processing aborted.")) do
doc.root.children.first.value
end
end
- end
- class ParameterEntityTest < self
- def test_have_value
- xml = <<EOF
-<!DOCTYPE root [
- <!ENTITY % a "BOOM.BOOM.BOOM.BOOM.BOOM.BOOM.BOOM.BOOM.BOOM.">
- <!ENTITY % b "%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;">
- <!ENTITY % c "%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;">
- <!ENTITY % d "%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;">
- <!ENTITY % e "%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;">
- <!ENTITY % f "%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;">
- <!ENTITY % g "%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;">
- <!ENTITY test "test %g;">
-]>
-<cd></cd>
-EOF
-
- assert_raise(REXML::ParseException) do
- REXML::Document.new(xml)
- end
- REXML::Security.entity_expansion_limit = 100
- assert_equal(100, REXML::Security.entity_expansion_limit)
- assert_raise(REXML::ParseException) do
- REXML::Document.new(xml)
- end
- end
-
- def test_empty_value
- xml = <<EOF
-<!DOCTYPE root [
- <!ENTITY % a "">
- <!ENTITY % b "%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;%a;">
- <!ENTITY % c "%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;%b;">
- <!ENTITY % d "%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;%c;">
- <!ENTITY % e "%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;">
- <!ENTITY % f "%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;%e;">
- <!ENTITY % g "%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;%f;">
- <!ENTITY test "test %g;">
+ def test_entity_expansion_text_limit
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE member [
+ <!ENTITY a "&b;&b;&b;">
+ <!ENTITY b "&c;&d;&e;">
+ <!ENTITY c "xxxxxxxxxx">
+ <!ENTITY d "yyyyyyyyyy">
+ <!ENTITY e "zzzzzzzzzz">
]>
-<cd></cd>
-EOF
+<member>&a;</member>
+ XML
- assert_raise(REXML::ParseException) do
- REXML::Document.new(xml)
- end
- REXML::Security.entity_expansion_limit = 100
- assert_equal(100, REXML::Security.entity_expansion_limit)
- assert_raise(REXML::ParseException) do
- REXML::Document.new(xml)
- end
+ doc = REXML::Document.new(xml)
+ doc.entity_expansion_text_limit = 90
+ assert_equal(90, doc.root.children.first.value.bytesize)
end
end
end
@@ -203,9 +159,45 @@ def test_xml_declaration_standalone
assert_equal('no', doc.stand_alone?, bug2539)
end
+ def test_each_recursive
+ xml_source = <<~XML
+ <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+ <root name="root">
+ <x name="1_1">
+ <x name="1_2">
+ <x name="1_3" />
+ </x>
+ </x>
+ <x name="2_1">
+ <x name="2_2">
+ <x name="2_3" />
+ </x>
+ </x>
+ <!-- comment -->
+ <![CDATA[ cdata ]]>
+ </root>
+ XML
+
+ expected_names = %w[
+ root
+ 1_1 1_2 1_3
+ 2_1 2_2 2_3
+ ]
+
+ document = REXML::Document.new(xml_source)
+
+ # Node#each_recursive iterates elements only.
+ # This does not iterate XML declarations, comments, attributes, CDATA sections, etc.
+ actual_names = []
+ document.each_recursive do |element|
+ actual_names << element.attributes["name"]
+ end
+ assert_equal(expected_names, actual_names)
+ end
+
class WriteTest < Test::Unit::TestCase
def setup
- @document = REXML::Document.new(<<-EOX)
+ @document = REXML::Document.new(<<-EOX.chomp)
<?xml version="1.0" encoding="UTF-8"?>
<message>Hello world!</message>
EOX
@@ -215,7 +207,7 @@ class ArgumentsTest < self
def test_output
output = ""
@document.write(output)
- assert_equal(<<-EOX, output)
+ assert_equal(<<-EOX.chomp, output)
<?xml version='1.0' encoding='UTF-8'?>
<message>Hello world!</message>
EOX
@@ -238,7 +230,7 @@ def test_transitive
indent = 2
transitive = true
@document.write(output, indent, transitive)
- assert_equal(<<-EOX, output)
+ assert_equal(<<-EOX.chomp, output)
<?xml version='1.0' encoding='UTF-8'?>
<message
>Hello world!</message
@@ -267,7 +259,7 @@ def test_encoding
japanese_text = "こんにちは"
@document.root.text = japanese_text
@document.write(output, indent, transitive, ie_hack, encoding)
- assert_equal(<<-EOX.encode(encoding), output)
+ assert_equal(<<-EOX.chomp.encode(encoding), output)
<?xml version='1.0' encoding='SHIFT_JIS'?>
<message>#{japanese_text}</message>
EOX
@@ -278,7 +270,7 @@ class OptionsTest < self
def test_output
output = ""
@document.write(:output => output)
- assert_equal(<<-EOX, output)
+ assert_equal(<<-EOX.chomp, output)
<?xml version='1.0' encoding='UTF-8'?>
<message>Hello world!</message>
EOX
@@ -298,7 +290,7 @@ def test_indent
def test_transitive
output = ""
@document.write(:output => output, :indent => 2, :transitive => true)
- assert_equal(<<-EOX, output)
+ assert_equal(<<-EOX.chomp, output)
<?xml version='1.0' encoding='UTF-8'?>
<message
>Hello world!</message
@@ -320,7 +312,7 @@ def test_encoding
japanese_text = "こんにちは"
@document.root.text = japanese_text
@document.write(:output => output, :encoding => encoding)
- assert_equal(<<-EOX.encode(encoding), output)
+ assert_equal(<<-EOX.chomp.encode(encoding), output)
<?xml version='1.0' encoding='SHIFT_JIS'?>
<message>#{japanese_text}</message>
EOX
@@ -404,7 +396,7 @@ def test_utf_16
actual_xml = ""
document.write(actual_xml)
- expected_xml = <<-EOX.encode("UTF-16BE")
+ expected_xml = <<-EOX.chomp.encode("UTF-16BE")
\ufeff<?xml version='1.0' encoding='UTF-16'?>
<message>Hello world!</message>
EOX
diff --git a/test/rexml/test_element.rb b/test/rexml/test_element.rb
index 82830b44e6..202168955c 100644
--- a/test/rexml/test_element.rb
+++ b/test/rexml/test_element.rb
@@ -1,8 +1,5 @@
# frozen_string_literal: false
-require "test/unit/testcase"
-require "rexml/document"
-
module REXMLTests
class ElementTester < Test::Unit::TestCase
def test_array_reference_string
diff --git a/test/rexml/test_elements.rb b/test/rexml/test_elements.rb
index a850e62209..c0f1b22007 100644
--- a/test/rexml/test_elements.rb
+++ b/test/rexml/test_elements.rb
@@ -1,6 +1,4 @@
# frozen_string_literal: false
-require 'test/unit/testcase'
-require 'rexml/document'
module REXMLTests
class ElementsTester < Test::Unit::TestCase
@@ -115,5 +113,10 @@ def test_inject
}
assert_equal 6, r
end
+
+ def test_parent
+ doc = Document.new( "<a><b id='1'/><b id='2'/></a>" )
+ assert_equal('a', doc.root.elements.parent.name)
+ end
end
end
diff --git a/test/rexml/test_encoding.rb b/test/rexml/test_encoding.rb
index 919db131f0..586f1f8b68 100644
--- a/test/rexml/test_encoding.rb
+++ b/test/rexml/test_encoding.rb
@@ -1,14 +1,15 @@
-# coding: binary
+# coding: utf-8
# frozen_string_literal: false
-require_relative "rexml_test_utils"
-
require 'rexml/source'
require 'rexml/document'
+require_relative "helper"
+
module REXMLTests
class EncodingTester < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
+ include Helper::Global
include REXML
def setup
@@ -23,7 +24,7 @@ def test_encoded_in_encoded_out
doc = Document.new( @encoded )
doc.write( out="" )
out.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( @encoded, out )
+ assert_equal( @encoded.b, out )
end
# Given an encoded document, try to change the encoding and write it out
@@ -33,10 +34,10 @@ def test_encoded_in_change_out
assert_equal("UTF-8", doc.encoding)
REXML::Formatters::Default.new.write( doc.root, out="" )
out.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( @not_encoded, out )
+ assert_equal( @not_encoded.b, out )
char = XPath.first( doc, "/a/b/text()" ).to_s
char.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( "ĉ", char )
+ assert_equal( "ĉ".b, char )
end
# * Given an encoded document, try to write it to a different encoding
@@ -44,7 +45,7 @@ def test_encoded_in_different_out
doc = Document.new( @encoded )
REXML::Formatters::Default.new.write( doc.root, Output.new( out="", "UTF-8" ) )
out.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( @not_encoded, out )
+ assert_equal( @not_encoded.b, out )
end
# * Given a non-encoded document, change the encoding
@@ -54,7 +55,7 @@ def test_in_change_out
assert_equal("ISO-8859-3", doc.encoding)
doc.write( out="" )
out.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( @encoded, out )
+ assert_equal( @encoded.b, out )
end
# * Given a non-encoded document, write to a different encoding
@@ -62,13 +63,13 @@ def test_in_different_out
doc = Document.new( @not_encoded )
doc.write( Output.new( out="", "ISO-8859-3" ) )
out.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( "<?xml version='1.0'?>#{@encoded_root}", out )
+ assert_equal( "<?xml version='1.0'?>#{@encoded_root}".b, out )
end
# * Given an encoded document, accessing text and attribute nodes
# should provide UTF-8 text.
def test_in_different_access
- doc = Document.new <<-EOL
+ doc = Document.new <<~EOL
<?xml version='1.0' encoding='ISO-8859-1'?>
<a a="\xFF">\xFF</a>
EOL
@@ -80,7 +81,7 @@ def test_in_different_access
def test_ticket_89
- doc = Document.new <<-EOL
+ doc = Document.new <<~EOL
<?xml version="1.0" encoding="CP-1252" ?>
<xml><foo></foo></xml>
EOL
@@ -97,7 +98,7 @@ def test_parse_utf16
end
def test_parse_utf16_with_utf8_default_internal
- EnvUtil.with_default_internal("UTF-8") do
+ with_default_internal("UTF-8") do
utf16 = File.open(fixture_path("utf16.xml")) do |f|
REXML::Document.new(f)
end
diff --git a/test/rexml/test_entity.rb b/test/rexml/test_entity.rb
index 6dc6637074..89f8389445 100644
--- a/test/rexml/test_entity.rb
+++ b/test/rexml/test_entity.rb
@@ -1,7 +1,5 @@
# frozen_string_literal: false
-require "test/unit/testcase"
-require 'rexml/document'
require 'rexml/entity'
require 'rexml/source'
@@ -61,8 +59,7 @@ def test_parse_entity
def test_constructor
one = [ %q{<!ENTITY % YN '"Yes"'>},
- %q{<!ENTITY % YN2 "Yes">},
- %q{<!ENTITY WhatHeSaid "He said %YN;">},
+ %q{<!ENTITY WhatHeSaid 'He said "Yes"'>},
'<!ENTITY open-hatch
SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">',
'<!ENTITY open-hatch2
@@ -73,8 +70,7 @@ def test_constructor
NDATA gif>' ]
source = %q{<!DOCTYPE foo [
<!ENTITY % YN '"Yes"'>
- <!ENTITY % YN2 "Yes">
- <!ENTITY WhatHeSaid "He said %YN;">
+ <!ENTITY WhatHeSaid 'He said "Yes"'>
<!ENTITY open-hatch
SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">
<!ENTITY open-hatch2
@@ -106,6 +102,84 @@ def test_replace_entities
assert_equal source, out
end
+ def test_readers_with_reference
+ entity = REXML::Entity.new([:entitydecl, "a", "B", "%"])
+ assert_equal([
+ '<!ENTITY % a "B">',
+ "a",
+ "B",
+ "B",
+ "B",
+ ],
+ [
+ entity.to_s,
+ entity.name,
+ entity.value,
+ entity.normalized,
+ entity.unnormalized,
+ ])
+ end
+
+ def test_readers_without_reference
+ entity = REXML::Entity.new([:entitydecl, "a", "&b;"])
+ assert_equal([
+ '<!ENTITY a "&b;">',
+ "a",
+ "&b;",
+ "&b;",
+ "&b;",
+ ],
+ [
+ entity.to_s,
+ entity.name,
+ entity.value,
+ entity.normalized,
+ entity.unnormalized,
+ ])
+ end
+
+ def test_readers_with_nested_references
+ doctype = REXML::DocType.new('root')
+ doctype.add(REXML::Entity.new([:entitydecl, "a", "&b;"]))
+ doctype.add(REXML::Entity.new([:entitydecl, "b", "X"]))
+ assert_equal([
+ "a",
+ "&b;",
+ "&b;",
+ "X",
+ "b",
+ "X",
+ "X",
+ "X",
+ ],
+ [
+ doctype.entities["a"].name,
+ doctype.entities["a"].value,
+ doctype.entities["a"].normalized,
+ doctype.entities["a"].unnormalized,
+ doctype.entities["b"].name,
+ doctype.entities["b"].value,
+ doctype.entities["b"].normalized,
+ doctype.entities["b"].unnormalized,
+ ])
+ end
+
+ def test_parameter_entity_reference_forbidden_by_internal_subset_in_parser
+ source = '<!DOCTYPE root [ <!ENTITY % a "B" > <!ENTITY c "%a;" > ]><root/>'
+ parser = REXML::Parsers::BaseParser.new(source)
+ exception = assert_raise(REXML::ParseException) do
+ while parser.has_next?
+ parser.pull
+ end
+ end
+ assert_equal(<<-DETAIL, exception.to_s)
+Parameter entity references forbidden in internal subset: "%a;"
+Line: 1
+Position: 54
+Last 80 unconsumed characters:
+ DETAIL
+ end
+
def test_entity_string_limit
template = '<!DOCTYPE bomb [ <!ENTITY a "^" > ]> <bomb>$</bomb>'
len = 5120 # 5k per entity
@@ -124,22 +198,6 @@ def test_entity_string_limit
end
end
- def test_entity_string_limit_for_parameter_entity
- template = '<!DOCTYPE bomb [ <!ENTITY % a "^" > <!ENTITY bomb "$" > ]><root/>'
- len = 5120 # 5k per entity
- template.sub!(/\^/, "B" * len)
-
- # 10k is OK
- entities = '%a;' * 2 # 5k entity * 2 = 10k
- REXML::Document.new(template.sub(/\$/, entities))
-
- # above 10k explodes
- entities = '%a;' * 3 # 5k entity * 2 = 15k
- assert_raise(REXML::ParseException) do
- REXML::Document.new(template.sub(/\$/, entities))
- end
- end
-
def test_raw
source = '<!DOCTYPE foo [
<!ENTITY ent "replace">
@@ -163,7 +221,7 @@ def test_lazy_evaluation
def test_entity_replacement
source = %q{<!DOCTYPE foo [
<!ENTITY % YN '"Yes"'>
- <!ENTITY WhatHeSaid "He said %YN;">]>
+ <!ENTITY WhatHeSaid 'He said "Yes"'>]>
<a>&WhatHeSaid;</a>}
d = REXML::Document.new( source )
diff --git a/test/rexml/test_instruction.rb b/test/rexml/test_instruction.rb
new file mode 100644
index 0000000000..5451e367b8
--- /dev/null
+++ b/test/rexml/test_instruction.rb
@@ -0,0 +1,12 @@
+module REXMLTests
+ class InstructionTest < Test::Unit::TestCase
+ def test_target_nil
+ error = assert_raise(ArgumentError) do
+ REXML::Instruction.new(nil)
+ end
+ assert_equal("processing instruction target must be String or " +
+ "REXML::Instruction: <nil>",
+ error.message)
+ end
+ end
+end
diff --git a/test/rexml/test_jaxen.rb b/test/rexml/test_jaxen.rb
index 9cd7bee8c2..38d2e959c6 100644
--- a/test/rexml/test_jaxen.rb
+++ b/test/rexml/test_jaxen.rb
@@ -1,5 +1,4 @@
# frozen_string_literal: false
-require_relative 'rexml_test_utils'
require "rexml/document"
require "rexml/xpath"
@@ -7,124 +6,127 @@
# Harness to test REXML's capabilities against the test suite from Jaxen
# ryan.a.cox@gmail.com
+require_relative "helper"
+
module REXMLTests
class JaxenTester < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
include REXML
- def test_axis ; test("axis") ; end
- def test_basic ; test("basic") ; end
- def test_basicupdate ; test("basicupdate") ; end
- def test_contents ; test("contents") ; end
- def test_defaultNamespace ; test("defaultNamespace") ; end
- def test_fibo ; test("fibo") ; end
- def test_id ; test("id") ; end
- def test_jaxen24 ; test("jaxen24") ; end
- def test_lang ; test("lang") ; end
- def test_message ; test("message") ; end
- def test_moreover ; test("moreover") ; end
- def test_much_ado ; test("much_ado") ; end
- def test_namespaces ; test("namespaces") ; end
- def test_nitf ; test("nitf") ; end
- def test_numbers ; test("numbers") ; end
- def test_pi ; test("pi") ; end
- def test_pi2 ; test("pi2") ; end
- def test_simple ; test("simple") ; end
- def test_testNamespaces ; test("testNamespaces") ; end
- def test_text ; test("text") ; end
- def test_underscore ; test("underscore") ; end
- def test_web ; test("web") ; end
- def test_web2 ; test("web2") ; end
+ def test_axis ; process_test_case("axis") ; end
+ def test_basic ; process_test_case("basic") ; end
+ def test_basicupdate ; process_test_case("basicupdate") ; end
+ def test_contents ; process_test_case("contents") ; end
+ def test_defaultNamespace ; process_test_case("defaultNamespace") ; end
+ def test_fibo ; process_test_case("fibo") ; end
+ def test_id ; process_test_case("id") ; end
+ def test_jaxen24 ; process_test_case("jaxen24") ; end
+ def test_lang ; process_test_case("lang") ; end
+ # document() function for XSLT isn't supported
+ def _test_message ; process_test_case("message") ; end
+ def test_moreover ; process_test_case("moreover") ; end
+ def test_much_ado ; process_test_case("much_ado") ; end
+ def test_namespaces ; process_test_case("namespaces") ; end
+ def test_nitf ; process_test_case("nitf") ; end
+ # Exception should be considered
+ def _test_numbers ; process_test_case("numbers") ; end
+ def test_pi ; process_test_case("pi") ; end
+ def test_pi2 ; process_test_case("pi2") ; end
+ def test_simple ; process_test_case("simple") ; end
+ # TODO: namespace node is needed
+ def _test_testNamespaces ; process_test_case("testNamespaces") ; end
+ # document() function for XSLT isn't supported
+ def _test_text ; process_test_case("text") ; end
+ def test_underscore ; process_test_case("underscore") ; end
+ def _test_web ; process_test_case("web") ; end
+ def test_web2 ; process_test_case("web2") ; end
private
- def test( fname )
-# Dir.entries( xml_dir ).each { |fname|
-# if fname =~ /\.xml$/
- doc = File.open(fixture_path(fname+".xml")) do |file|
- Document.new(file)
- end
- XPath.each( doc, "/tests/document" ) {|e| handleDocument(e)}
-# end
-# }
+ def process_test_case(name)
+ xml_path = "#{name}.xml"
+ doc = File.open(fixture_path(xml_path)) do |file|
+ Document.new(file)
+ end
+ test_doc = File.open(fixture_path("test/tests.xml")) do |file|
+ Document.new(file)
+ end
+ XPath.each(test_doc,
+ "/tests/document[@url='xml/#{xml_path}']/context") do |context|
+ process_context(doc, context)
+ end
end
# processes a tests/document/context node
- def handleContext( testDoc, ctxElement)
- testCtx = XPath.match( testDoc, ctxElement.attributes["select"] )[0]
- namespaces = {}
- if testCtx.class == Element
- testCtx.prefixes.each { |pre| handleNamespace( testCtx, pre, namespaces ) }
- end
+ def process_context(doc, context)
+ test_context = XPath.match(doc, context.attributes["select"])
+ namespaces = context.namespaces
+ namespaces.delete("var")
+ namespaces = nil if namespaces.empty?
variables = {}
- XPath.each( ctxElement, "@*[namespace-uri() = 'http://jaxen.org/test-harness/var']") { |attrib| handleVariable(testCtx, variables, attrib) }
- XPath.each( ctxElement, "valueOf") { |e| handleValueOf(testCtx, variables, namespaces, e) }
- XPath.each( ctxElement, "test[not(@exception) or (@exception != 'true') ]") { |e| handleNominalTest(testCtx,variables, namespaces, e) }
- XPath.each( ctxElement, "test[@exception = 'true']") { |e| handleExceptionalTest(testCtx,variables, namespaces, e) }
+ var_namespace = "http://jaxen.org/test-harness/var"
+ XPath.each(context,
+ "@*[namespace-uri() = '#{var_namespace}']") do |attribute|
+ variables[attribute.name] = attribute.value
+ end
+ XPath.each(context, "valueOf") do |value|
+ process_value_of(test_context, variables, namespaces, value)
+ end
+ XPath.each(context,
+ "test[not(@exception) or (@exception != 'true')]") do |test|
+ process_nominal_test(test_context, variables, namespaces, test)
+ end
+ XPath.each(context,
+ "test[@exception = 'true']") do |test|
+ process_exceptional_test(test_context, variables, namespaces, test)
+ end
end
# processes a tests/document/context/valueOf or tests/document/context/test/valueOf node
- def handleValueOf(ctx,variables, namespaces, valueOfElement)
- expected = valueOfElement.text
- got = XPath.match( ctx, valueOfElement.attributes["select"], namespaces, variables )[0]
- assert_true( (got.nil? && expected.nil?) || !got.nil? )
- case got.class
- when Element
- assert_equal( got.class, Element )
- when Attribute, Text, Comment, TrueClass, FalseClass
- assert_equal( expected, got.to_s )
- when Instruction
- assert_equal( expected, got.content )
- when Integer
- assert_equal( exected.to_f, got )
- when String
- # normalize values for comparison
- got = "" if got == nil or got == ""
- expected = "" if expected == nil or expected == ""
- assert_equal( expected, got )
- else
- assert_fail( "Wassup?" )
- end
- end
+ def process_value_of(context, variables, namespaces, value_of)
+ expected = value_of.text
+ xpath = value_of.attributes["select"]
+ matched = XPath.match(context, xpath, namespaces, variables, strict: true)
+ message = user_message(context, xpath, matched)
+ assert_equal(expected || "",
+ REXML::Functions.string(matched),
+ message)
+ end
# processes a tests/document/context/test node ( where @exception is false or doesn't exist )
- def handleNominalTest(ctx, variables, namespaces, testElement)
- expected = testElement.attributes["count"]
- got = XPath.match( ctx, testElement.attributes["select"], namespaces, variables )
+ def process_nominal_test(context, variables, namespaces, test)
+ xpath = test.attributes["select"]
+ matched = XPath.match(context, xpath, namespaces, variables, strict: true)
# might be a test with no count attribute, but nested valueOf elements
- assert( expected == got.size.to_s ) if !expected.nil?
+ expected = test.attributes["count"]
+ if expected
+ assert_equal(Integer(expected, 10),
+ matched.size,
+ user_message(context, xpath, matched))
+ end
- XPath.each( testElement, "valueOf") { |e|
- handleValueOf(got, variables, namespaces, e)
- }
+ XPath.each(test, "valueOf") do |value_of|
+ process_value_of(matched, variables, namespaces, value_of)
+ end
end
# processes a tests/document/context/test node ( where @exception is true )
- def handleExceptionalTest(ctx, variables, namespaces, testElement)
- assert_raise( Exception ) {
- XPath.match( ctx, testElement.attributes["select"], namespaces, variables )
- }
- end
-
- # processes a tests/document node
- def handleDocument(docElement)
- puts "- Processing document: #{docElement.attributes['url']}"
- testFile = File.new( docElement.attributes["url"] )
- testDoc = Document.new testFile
- XPath.each( docElement, "context") { |e| handleContext(testDoc, e) }
- end
-
- # processes a variable definition in a namespace like <test var:foo="bar">
- def handleVariable( ctx, variables, attrib )
- puts "--- Found attribute: #{attrib.name}"
- variables[attrib.name] = attrib.value
+ def process_exceptional_test(context, variables, namespaces, test)
+ xpath = test.attributes["select"]
+ assert_raise(REXML::ParseException) do
+ XPath.match(context, xpath, namespaces, variables, strict: true)
+ end
end
- # processes a namespace definition like <test xmlns:foo="fiz:bang:bam">
- def handleNamespace( ctx, prefix, namespaces )
- puts "--- Found namespace: #{prefix}"
- namespaces[prefix] = ctx.namespaces[prefix]
+ def user_message(context, xpath, matched)
+ message = ""
+ context.each_with_index do |node, i|
+ message << "Node#{i}:\n"
+ message << "#{node}\n"
+ end
+ message << "XPath: <#{xpath}>\n"
+ message << "Matched <#{matched}>"
+ message
end
-
end
end
diff --git a/test/rexml/test_light.rb b/test/rexml/test_light.rb
index 99bd9cac3f..fd39948daa 100644
--- a/test/rexml/test_light.rb
+++ b/test/rexml/test_light.rb
@@ -1,18 +1,20 @@
# frozen_string_literal: false
-require_relative "rexml_test_utils"
+
require "rexml/light/node"
require "rexml/parsers/lightparser"
+require_relative "helper"
+
module REXMLTests
class LightTester < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
include REXML::Light
def test_parse_large
- xml_string = fixture_path("documentation.xml")
+ xml_string = File.read(fixture_path("documentation.xml"))
parser = REXML::Parsers::LightParser.new(xml_string)
tag, content = parser.parse
- assert_equal([:document, :text], [tag, content.first])
+ assert_equal([:document, :xmldecl], [tag, content.first])
end
# FIXME INCOMPLETE
@@ -62,7 +64,7 @@ def test_access_child_elements
assert_equal( 'c', a[1].name )
end
- def test_itterate_over_children
+ def test_iterate_over_children
foo = make_small_document
ctr = 0
foo[0].each { ctr += 1 }
diff --git a/test/rexml/test_lightparser.rb b/test/rexml/test_lightparser.rb
index 1aeac072dd..507e067b17 100644
--- a/test/rexml/test_lightparser.rb
+++ b/test/rexml/test_lightparser.rb
@@ -1,10 +1,12 @@
# frozen_string_literal: false
-require_relative 'rexml_test_utils'
+
require 'rexml/parsers/lightparser'
+require_relative "helper"
+
module REXMLTests
class LightParserTester < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
include REXML
def test_parsing
File.open(fixture_path("documentation.xml")) do |f|
diff --git a/test/rexml/test_listener.rb b/test/rexml/test_listener.rb
index 322d368be8..ae834a1fb6 100644
--- a/test/rexml/test_listener.rb
+++ b/test/rexml/test_listener.rb
@@ -1,14 +1,13 @@
# coding: binary
# frozen_string_literal: false
-require_relative 'rexml_test_utils'
-
-require 'rexml/document'
require 'rexml/streamlistener'
+require_relative "helper"
+
module REXMLTests
class BaseTester < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
def test_empty
return unless defined? @listener
# Empty.
diff --git a/test/rexml/test_martin_fowler.rb b/test/rexml/test_martin_fowler.rb
index da685a80ec..ce27d72576 100644
--- a/test/rexml/test_martin_fowler.rb
+++ b/test/rexml/test_martin_fowler.rb
@@ -1,9 +1,7 @@
# frozen_string_literal: false
-require 'test/unit'
-require 'rexml/document'
module REXMLTests
- class OrderTester < Test::Unit::TestCase
+ class OrderTesterMF < Test::Unit::TestCase
DOC = <<END
<paper>
<title>Remove this element and figs order differently</title>
@@ -18,12 +16,12 @@ class OrderTester < Test::Unit::TestCase
</paper>
END
- def initialize n
+ def setup
@doc = REXML::Document.new(DOC)
@figs = REXML::XPath.match(@doc,'//figure')
@names = @figs.collect {|f| f.attributes['src']}
- super
end
+
def test_fig1
assert_equal 'fig1', @figs[0].attributes['src']
end
diff --git a/test/rexml/test_namespace.rb b/test/rexml/test_namespace.rb
index 90e1d36945..57a0a3e5ad 100644
--- a/test/rexml/test_namespace.rb
+++ b/test/rexml/test_namespace.rb
@@ -1,11 +1,10 @@
# frozen_string_literal: false
-require_relative "rexml_test_utils"
-require "rexml/document"
+require_relative "helper"
module REXMLTests
class TestNamespace < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
include REXML
def setup
diff --git a/test/rexml/test_order.rb b/test/rexml/test_order.rb
index 807d9faa96..6dc0204691 100644
--- a/test/rexml/test_order.rb
+++ b/test/rexml/test_order.rb
@@ -1,14 +1,15 @@
# frozen_string_literal: false
-require_relative 'rexml_test_utils'
-require 'rexml/document'
+
begin
require 'zlib'
rescue LoadError
end
+require_relative "helper"
+
module REXMLTests
class OrderTester < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
TESTDOC = <<END
<a>
diff --git a/test/rexml/test_preceding_sibling.rb b/test/rexml/test_preceding_sibling.rb
index d89a1e1c90..7e661eb00c 100644
--- a/test/rexml/test_preceding_sibling.rb
+++ b/test/rexml/test_preceding_sibling.rb
@@ -1,7 +1,5 @@
# frozen_string_literal: false
# ISSUE 32
-require 'test/unit'
-require 'rexml/document'
module REXMLTests
# daz - for report by Dan Kohn in:
diff --git a/test/rexml/test_pullparser.rb b/test/rexml/test_pullparser.rb
index 31b5b74bd6..bdf8be17fa 100644
--- a/test/rexml/test_pullparser.rb
+++ b/test/rexml/test_pullparser.rb
@@ -1,5 +1,4 @@
# frozen_string_literal: false
-require "test/unit/testcase"
require 'rexml/parsers/pullparser'
@@ -63,6 +62,63 @@ def test_entity_replacement
end
end
+ def test_character_references
+ source = '<root><a>A</a><b>B</b></root>'
+ parser = REXML::Parsers::PullParser.new( source )
+
+ events = {}
+ element_name = ''
+ while parser.has_next?
+ event = parser.pull
+ case event.event_type
+ when :start_element
+ element_name = event[0]
+ when :text
+ events[element_name] = event[1]
+ end
+ end
+
+ assert_equal('A', events['a'])
+ assert_equal("B", events['b'])
+ end
+
+ def test_text_entity_references
+ source = '<root><a><P> <I> <B> Text </B> </I></a></root>'
+ parser = REXML::Parsers::PullParser.new( source )
+
+ events = []
+ while parser.has_next?
+ event = parser.pull
+ case event.event_type
+ when :text
+ events << event[1]
+ end
+ end
+
+ assert_equal(["<P> <I> <B> Text </B> </I>"], events)
+ end
+
+ def test_text_content_with_line_breaks
+ source = "<root><a>A</a><b>B\n</b><c>C\r\n</c></root>"
+ parser = REXML::Parsers::PullParser.new( source )
+
+ events = {}
+ element_name = ''
+ while parser.has_next?
+ event = parser.pull
+ case event.event_type
+ when :start_element
+ element_name = event[0]
+ when :text
+ events[element_name] = event[1]
+ end
+ end
+
+ assert_equal('A', events['a'])
+ assert_equal("B\n", events['b'])
+ assert_equal("C\n", events['c'])
+ end
+
def test_peek_unshift
source = "<a><b/></a>"
REXML::Parsers::PullParser.new(source)
@@ -99,5 +155,152 @@ def test_peek
end
assert_equal( 0, names.length )
end
+
+ class EntityExpansionLimitTest < Test::Unit::TestCase
+ class GeneralEntityTest < self
+ def test_have_value
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE member [
+ <!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
+ <!ENTITY b "&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;">
+ <!ENTITY c "&d;&d;&d;&d;&d;&d;&d;&d;&d;&d;">
+ <!ENTITY d "&e;&e;&e;&e;&e;&e;&e;&e;&e;&e;">
+ <!ENTITY e "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx">
+]>
+<member>
+&a;
+</member>
+ XML
+
+ parser = REXML::Parsers::PullParser.new(source)
+ assert_raise(RuntimeError.new("entity expansion has grown too large")) do
+ while parser.has_next?
+ parser.pull
+ end
+ end
+ end
+
+ def test_empty_value
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE member [
+ <!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
+ <!ENTITY b "&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;">
+ <!ENTITY c "&d;&d;&d;&d;&d;&d;&d;&d;&d;&d;">
+ <!ENTITY d "&e;&e;&e;&e;&e;&e;&e;&e;&e;&e;">
+ <!ENTITY e "">
+]>
+<member>
+&a;
+</member>
+ XML
+
+ parser = REXML::Parsers::PullParser.new(source)
+ parser.entity_expansion_limit = 100000
+ while parser.has_next?
+ parser.pull
+ end
+ assert_equal(11111, parser.entity_expansion_count)
+
+ parser = REXML::Parsers::PullParser.new(source)
+ assert_raise(RuntimeError.new("number of entity expansions exceeded, processing aborted.")) do
+ while parser.has_next?
+ parser.pull
+ end
+ end
+ assert do
+ parser.entity_expansion_count > REXML::Security.entity_expansion_limit
+ end
+ end
+
+ def test_with_default_entity
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE member [
+ <!ENTITY a "a">
+ <!ENTITY a2 "&a; &a;">
+]>
+<member>
+&a;
+&a2;
+<
+</member>
+ XML
+
+ parser = REXML::Parsers::PullParser.new(source)
+ parser.entity_expansion_limit = 4
+ while parser.has_next?
+ parser.pull
+ end
+
+ parser = REXML::Parsers::PullParser.new(source)
+ parser.entity_expansion_limit = 3
+ assert_raise(RuntimeError.new("number of entity expansions exceeded, processing aborted.")) do
+ while parser.has_next?
+ parser.pull
+ end
+ end
+ end
+
+ def test_with_only_default_entities
+ member_value = "<p>#{'A' * REXML::Security.entity_expansion_text_limit}</p>"
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<member>
+#{member_value}
+</member>
+ XML
+
+ parser = REXML::Parsers::PullParser.new(source)
+ events = {}
+ element_name = ''
+ while parser.has_next?
+ event = parser.pull
+ case event.event_type
+ when :start_element
+ element_name = event[0]
+ when :text
+ events[element_name] = event[1]
+ end
+ end
+
+ expected_value = "<p>#{'A' * REXML::Security.entity_expansion_text_limit}</p>"
+ assert_equal(expected_value, events['member'].strip)
+ assert_equal(0, parser.entity_expansion_count)
+ assert do
+ events['member'].bytesize > REXML::Security.entity_expansion_text_limit
+ end
+ end
+
+ def test_entity_expansion_text_limit
+ source = <<-XML
+<!DOCTYPE member [
+ <!ENTITY a "&b;&b;&b;">
+ <!ENTITY b "&c;&d;&e;">
+ <!ENTITY c "xxxxxxxxxx">
+ <!ENTITY d "yyyyyyyyyy">
+ <!ENTITY e "zzzzzzzzzz">
+]>
+<member>&a;</member>
+ XML
+
+ parser = REXML::Parsers::PullParser.new(source)
+ parser.entity_expansion_text_limit = 90
+ events = {}
+ element_name = ''
+ while parser.has_next?
+ event = parser.pull
+ case event.event_type
+ when :start_element
+ element_name = event[0]
+ when :text
+ events[element_name] = event[1]
+ end
+ end
+ assert_equal(90, events['member'].size)
+ end
+ end
+ end
end
end
diff --git a/test/rexml/test_rexml_issuezilla.rb b/test/rexml/test_rexml_issuezilla.rb
index 1c54c9d53d..fb9f75de9b 100644
--- a/test/rexml/test_rexml_issuezilla.rb
+++ b/test/rexml/test_rexml_issuezilla.rb
@@ -1,10 +1,10 @@
# frozen_string_literal: false
-require_relative 'rexml_test_utils'
-require 'rexml/document'
+
+require_relative "helper"
module REXMLTests
class TestIssuezillaParsing < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
def test_rexml
doc = File.open(fixture_path("ofbiz-issues-full-177.xml")) do |f|
REXML::Document.new(f)
diff --git a/test/rexml/test_sax.rb b/test/rexml/test_sax.rb
index 00539f0d4c..fa1d1cb612 100644
--- a/test/rexml/test_sax.rb
+++ b/test/rexml/test_sax.rb
@@ -1,12 +1,13 @@
# frozen_string_literal: false
-require_relative "rexml_test_utils"
+
require 'rexml/sax2listener'
require 'rexml/parsers/sax2parser'
-require 'rexml/document'
+
+require_relative "helper"
module REXMLTests
class SAX2Tester < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
include REXML
def test_characters
d = Document.new( "<A>@blah@</A>" )
@@ -32,6 +33,17 @@ def test_entity_replacement
assert_equal '--1234--', results[1]
end
+ def test_characters_predefined_entities
+ source = '<root><a><P> <I> <B> Text </B> </I></a></root>'
+
+ sax = Parsers::SAX2Parser.new( source )
+ results = []
+ sax.listen(:characters) {|x| results << x }
+ sax.parse
+
+ assert_equal(["<P> <I> <B> Text </B> </I>"], results)
+ end
+
def test_sax2
File.open(fixture_path("documentation.xml")) do |f|
parser = Parsers::SAX2Parser.new( f )
@@ -89,6 +101,177 @@ def test_sax2
end
end
+ def test_without_namespace
+ xml = <<-XML
+<root >
+ <a att1='1' att2='2' att3='<'>
+ <b />
+ </a>
+</root>
+ XML
+
+ parser = REXML::Parsers::SAX2Parser.new(xml)
+ elements = []
+ parser.listen(:start_element) do |uri, localname, qname, attrs|
+ elements << [uri, localname, qname, attrs]
+ end
+ parser.parse
+ assert_equal([
+ [nil, "root", "root", {}],
+ [nil, "a", "a", {"att1"=>"1", "att2"=>"2", "att3"=>"<"}],
+ [nil, "b", "b", {}]
+ ], elements)
+ end
+
+ def test_with_namespace
+ xml = <<-XML
+<root xmlns="http://example.org/default"
+ xmlns:foo="http://example.org/foo"
+ xmlns:bar="http://example.org/bar">
+ <a foo:att='1' bar:att='2' att='<'>
+ <bar:b />
+ </a>
+</root>
+ XML
+
+ parser = REXML::Parsers::SAX2Parser.new(xml)
+ elements = []
+ parser.listen(:start_element) do |uri, localname, qname, attrs|
+ elements << [uri, localname, qname, attrs]
+ end
+ parser.parse
+ assert_equal([
+ ["http://example.org/default", "root", "root", {"xmlns"=>"http://example.org/default", "xmlns:bar"=>"http://example.org/bar", "xmlns:foo"=>"http://example.org/foo"}],
+ ["http://example.org/default", "a", "a", {"att"=>"<", "bar:att"=>"2", "foo:att"=>"1"}],
+ ["http://example.org/bar", "b", "bar:b", {}]
+ ], elements)
+ end
+
+ class EntityExpansionLimitTest < Test::Unit::TestCase
+ class GeneralEntityTest < self
+ def test_have_value
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE member [
+ <!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
+ <!ENTITY b "&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;">
+ <!ENTITY c "&d;&d;&d;&d;&d;&d;&d;&d;&d;&d;">
+ <!ENTITY d "&e;&e;&e;&e;&e;&e;&e;&e;&e;&e;">
+ <!ENTITY e "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx">
+]>
+<member>
+&a;
+</member>
+ XML
+
+ sax = REXML::Parsers::SAX2Parser.new(source)
+ assert_raise(RuntimeError.new("entity expansion has grown too large")) do
+ sax.parse
+ end
+ end
+
+ def test_empty_value
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE member [
+ <!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
+ <!ENTITY b "&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;">
+ <!ENTITY c "&d;&d;&d;&d;&d;&d;&d;&d;&d;&d;">
+ <!ENTITY d "&e;&e;&e;&e;&e;&e;&e;&e;&e;&e;">
+ <!ENTITY e "">
+]>
+<member>
+&a;
+</member>
+ XML
+
+ sax = REXML::Parsers::SAX2Parser.new(source)
+ sax.entity_expansion_limit = 100000
+ sax.parse
+ assert_equal(11111, sax.entity_expansion_count)
+
+ sax = REXML::Parsers::SAX2Parser.new(source)
+ assert_raise(RuntimeError.new("number of entity expansions exceeded, processing aborted.")) do
+ sax.parse
+ end
+ assert do
+ sax.entity_expansion_count > REXML::Security.entity_expansion_limit
+ end
+ end
+
+ def test_with_default_entity
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE member [
+ <!ENTITY a "a">
+ <!ENTITY a2 "&a; &a;">
+]>
+<member>
+&a;
+&a2;
+<
+</member>
+ XML
+
+ sax = REXML::Parsers::SAX2Parser.new(source)
+ sax.entity_expansion_limit = 4
+ sax.parse
+
+ sax = REXML::Parsers::SAX2Parser.new(source)
+ sax.entity_expansion_limit = 3
+ assert_raise(RuntimeError.new("number of entity expansions exceeded, processing aborted.")) do
+ sax.parse
+ end
+ end
+
+ def test_with_only_default_entities
+ member_value = "<p>#{'A' * REXML::Security.entity_expansion_text_limit}</p>"
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<member>
+#{member_value}
+</member>
+ XML
+
+ sax = REXML::Parsers::SAX2Parser.new(source)
+ text_value = nil
+ sax.listen(:characters, ["member"]) do |text|
+ text_value = text
+ end
+ sax.parse
+
+ expected_value = "<p>#{'A' * REXML::Security.entity_expansion_text_limit}</p>"
+ assert_equal(expected_value, text_value.strip)
+ assert_equal(0, sax.entity_expansion_count)
+ assert do
+ text_value.bytesize > REXML::Security.entity_expansion_text_limit
+ end
+ end
+
+ def test_entity_expansion_text_limit
+ source = <<-XML
+<!DOCTYPE member [
+ <!ENTITY a "&b;&b;&b;">
+ <!ENTITY b "&c;&d;&e;">
+ <!ENTITY c "xxxxxxxxxx">
+ <!ENTITY d "yyyyyyyyyy">
+ <!ENTITY e "zzzzzzzzzz">
+]>
+<member>&a;</member>
+ XML
+
+ sax = REXML::Parsers::SAX2Parser.new(source)
+ sax.entity_expansion_text_limit = 90
+ text_size = nil
+ sax.listen(:characters, ["member"]) do |text|
+ text_size = text.size
+ end
+ sax.parse
+ assert_equal(90, text_size)
+ end
+ end
+ end
+
# used by test_simple_doctype_listener
# submitted by Jeff Barczewski
class SimpleDoctypeListener
@@ -110,7 +293,7 @@ def doctype(name, pub_sys, long_name, uri)
# test simple non-entity doctype in sax listener
# submitted by Jeff Barczewski
def test_simple_doctype_listener
- xml = <<-END
+ xml = <<~END
<?xml version="1.0"?>
<!DOCTYPE greeting PUBLIC "Hello Greeting DTD" "http://foo/hello.dtd">
<greeting>Hello, world!</greeting>
@@ -141,8 +324,8 @@ def test_simple_doctype_listener
# test doctype with missing name, should throw ParseException
# submitted by Jeff Barczewseki
- def test_doctype_with_mising_name_throws_exception
- xml = <<-END
+ def test_doctype_with_missing_name_throws_exception
+ xml = <<~END
<?xml version="1.0"?>
<!DOCTYPE >
<greeting>Hello, world!</greeting>
diff --git a/test/rexml/test_stream.rb b/test/rexml/test_stream.rb
index d7ceedc70e..7917760ae6 100644
--- a/test/rexml/test_stream.rb
+++ b/test/rexml/test_stream.rb
@@ -1,6 +1,5 @@
# frozen_string_literal: false
-require "test/unit/testcase"
-require "rexml/document"
+
require 'rexml/streamlistener'
require 'stringio'
@@ -15,8 +14,8 @@ class StreamTester < Test::Unit::TestCase
def test_listener
data = %Q{<session1 user="han" password="rootWeiler" />\n<session2 user="han" password="rootWeiler" />}
- b = RequestReader.new( data )
- b = RequestReader.new( data )
+ RequestReader.new( data )
+ RequestReader.new( data )
end
def test_ticket_49
@@ -88,8 +87,175 @@ def entity(content)
assert_equal(["ISOLat2"], listener.entities)
end
+
+ def test_entity_replacement
+ source = <<-XML
+<!DOCTYPE foo [
+ <!ENTITY la "1234">
+ <!ENTITY lala "--&la;--">
+ <!ENTITY lalal "&la;&la;">
+]><a><la>&la;</la><lala>&lala;</lala></a>
+ XML
+
+ listener = MyListener.new
+ class << listener
+ attr_accessor :text_values
+ def text(text)
+ @text_values << text
+ end
+ end
+ listener.text_values = []
+ REXML::Document.parse_stream(source, listener)
+ assert_equal(["1234", "--1234--"], listener.text_values)
+ end
+
+ def test_characters_predefined_entities
+ source = '<root><a><P> <I> <B> Text </B> </I></a></root>'
+
+ listener = MyListener.new
+ class << listener
+ attr_accessor :text_value
+ def text(text)
+ @text_value << text
+ end
+ end
+ listener.text_value = ""
+ REXML::Document.parse_stream(source, listener)
+ assert_equal("<P> <I> <B> Text </B> </I>", listener.text_value)
+ end
end
+ class EntityExpansionLimitTest < Test::Unit::TestCase
+ def test_have_value
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE member [
+ <!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
+ <!ENTITY b "&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;">
+ <!ENTITY c "&d;&d;&d;&d;&d;&d;&d;&d;&d;&d;">
+ <!ENTITY d "&e;&e;&e;&e;&e;&e;&e;&e;&e;&e;">
+ <!ENTITY e "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx">
+]>
+<member>
+&a;
+</member>
+ XML
+
+ assert_raise(RuntimeError.new("entity expansion has grown too large")) do
+ REXML::Document.parse_stream(source, MyListener.new)
+ end
+ end
+
+ def test_empty_value
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE member [
+ <!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
+ <!ENTITY b "&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;">
+ <!ENTITY c "&d;&d;&d;&d;&d;&d;&d;&d;&d;&d;">
+ <!ENTITY d "&e;&e;&e;&e;&e;&e;&e;&e;&e;&e;">
+ <!ENTITY e "">
+]>
+<member>
+&a;
+</member>
+ XML
+
+ listener = MyListener.new
+ parser = REXML::Parsers::StreamParser.new( source, listener )
+ parser.entity_expansion_limit = 100000
+ parser.parse
+ assert_equal(11111, parser.entity_expansion_count)
+
+ parser = REXML::Parsers::StreamParser.new( source, listener )
+ assert_raise(RuntimeError.new("number of entity expansions exceeded, processing aborted.")) do
+ parser.parse
+ end
+ assert do
+ parser.entity_expansion_count > REXML::Security.entity_expansion_limit
+ end
+ end
+
+ def test_with_default_entity
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE member [
+ <!ENTITY a "a">
+ <!ENTITY a2 "&a; &a;">
+]>
+<member>
+&a;
+&a2;
+<
+</member>
+ XML
+
+ listener = MyListener.new
+ parser = REXML::Parsers::StreamParser.new( source, listener )
+ parser.entity_expansion_limit = 4
+ parser.parse
+
+ parser = REXML::Parsers::StreamParser.new( source, listener )
+ parser.entity_expansion_limit = 3
+ assert_raise(RuntimeError.new("number of entity expansions exceeded, processing aborted.")) do
+ parser.parse
+ end
+ end
+
+ def test_with_only_default_entities
+ member_value = "<p>#{'A' * REXML::Security.entity_expansion_text_limit}</p>"
+ source = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<member>
+#{member_value}
+</member>
+ XML
+
+ listener = MyListener.new
+ class << listener
+ attr_accessor :text_value
+ def text(text)
+ @text_value << text
+ end
+ end
+ listener.text_value = ""
+ parser = REXML::Parsers::StreamParser.new( source, listener )
+ parser.parse
+
+ expected_value = "<p>#{'A' * REXML::Security.entity_expansion_text_limit}</p>"
+ assert_equal(expected_value, listener.text_value.strip)
+ assert_equal(0, parser.entity_expansion_count)
+ assert do
+ listener.text_value.bytesize > REXML::Security.entity_expansion_text_limit
+ end
+ end
+
+ def test_entity_expansion_text_limit
+ source = <<-XML
+<!DOCTYPE member [
+ <!ENTITY a "&b;&b;&b;">
+ <!ENTITY b "&c;&d;&e;">
+ <!ENTITY c "xxxxxxxxxx">
+ <!ENTITY d "yyyyyyyyyy">
+ <!ENTITY e "zzzzzzzzzz">
+]>
+<member>&a;</member>
+ XML
+
+ listener = MyListener.new
+ class << listener
+ attr_accessor :text_value
+ def text(text)
+ @text_value << text
+ end
+ end
+ listener.text_value = ""
+ parser = REXML::Parsers::StreamParser.new( source, listener )
+ parser.entity_expansion_text_limit = 90
+ parser.parse
+ assert_equal(90, listener.text_value.size)
+ end
+ end
# For test_listener
class RequestReader
diff --git a/test/rexml/test_text.rb b/test/rexml/test_text.rb
index 3f8036eee3..bae216562e 100644
--- a/test/rexml/test_text.rb
+++ b/test/rexml/test_text.rb
@@ -1,10 +1,55 @@
# frozen_string_literal: false
-require "rexml/text"
module REXMLTests
class TextTester < Test::Unit::TestCase
include REXML
+ def test_new_text_response_whitespace_default
+ text = Text.new("a b\t\tc", true)
+ assert_equal("a b\tc", Text.new(text).to_s)
+ end
+
+ def test_new_text_response_whitespace_true
+ text = Text.new("a b\t\tc", true)
+ assert_equal("a b\t\tc", Text.new(text, true).to_s)
+ end
+
+ def test_new_text_raw_default
+ text = Text.new("&lt;", false, nil, true)
+ assert_equal("&lt;", Text.new(text).to_s)
+ end
+
+ def test_new_text_raw_false
+ text = Text.new("&lt;", false, nil, true)
+ assert_equal("&amp;lt;", Text.new(text, false, nil, false).to_s)
+ end
+
+ def test_new_text_entity_filter_default
+ document = REXML::Document.new(<<-XML)
+<!DOCTYPE root [
+ <!ENTITY a "aaa">
+ <!ENTITY b "bbb">
+]>
+<root/>
+ XML
+ text = Text.new("aaa bbb", false, document.root, nil, ["a"])
+ assert_equal("aaa &b;",
+ Text.new(text, false, document.root).to_s)
+ end
+
+ def test_new_text_entity_filter_custom
+ document = REXML::Document.new(<<-XML)
+<!DOCTYPE root [
+ <!ENTITY a "aaa">
+ <!ENTITY b "bbb">
+]>
+<root/>
+ XML
+ text = Text.new("aaa bbb", false, document.root, nil, ["a"])
+ assert_equal("&a; bbb",
+ Text.new(text, false, document.root, nil, ["b"]).to_s)
+ end
+
def test_shift_operator_chain
text = Text.new("original\r\n")
text << "append1\r\n" << "append2\r\n"
@@ -18,5 +63,11 @@ def test_shift_operator_cache
text << "append3\r\n" << "append4\r\n"
assert_equal("original\nappend1\nappend2\nappend3\nappend4\n", text.to_s)
end
+
+ def test_clone
+ text = Text.new("&lt; <")
+ assert_equal(text.to_s,
+ text.clone.to_s)
+ end
end
end
diff --git a/test/rexml/test_text_check.rb b/test/rexml/test_text_check.rb
new file mode 100644
index 0000000000..11cf65a36f
--- /dev/null
+++ b/test/rexml/test_text_check.rb
@@ -0,0 +1,121 @@
+# frozen_string_literal: false
+
+module REXMLTests
+ class TextCheckTester < Test::Unit::TestCase
+
+ def check(string)
+ REXML::Text.check(string, REXML::Text::NEEDS_A_SECOND_CHECK, nil)
+ end
+
+ def assert_check(string)
+ assert_nothing_raised { check(string) }
+ end
+
+ def assert_check_failed(string, illegal_part)
+ message = "Illegal character #{illegal_part.inspect} in raw string #{string.inspect}"
+ assert_raise(RuntimeError.new(message)) do
+ check(string)
+ end
+ end
+
+ class TestValid < self
+ def test_entity_name_start_char_colon
+ assert_check("&:;")
+ end
+
+ def test_entity_name_start_char_under_score
+ assert_check("&_;")
+ end
+
+ def test_entity_name_mix
+ assert_check("&A.b-0123;")
+ end
+
+ def test_character_reference_decimal
+ assert_check("¢")
+ end
+
+ def test_character_reference_hex
+ assert_check("")
+ end
+
+ def test_entity_name_non_ascii
+ # U+3042 HIRAGANA LETTER A
+ # U+3044 HIRAGANA LETTER I
+ assert_check("&\u3042\u3044;")
+ end
+
+ def test_normal_string
+ assert_check("foo")
+ end
+ end
+
+ class TestInvalid < self
+ def test_lt
+ assert_check_failed("<;", "<")
+ end
+
+ def test_lt_mix
+ assert_check_failed("ab<cd", "<")
+ end
+
+ def test_reference_empty
+ assert_check_failed("&;", "&")
+ end
+
+ def test_entity_reference_missing_colon
+ assert_check_failed("&", "&")
+ end
+
+ def test_character_reference_decimal_garbage_at_the_end
+ # U+0030 DIGIT ZERO
+ assert_check_failed("0x;", "&")
+ end
+
+ def test_character_reference_decimal_space_at_the_start
+ # U+0030 DIGIT ZERO
+ assert_check_failed("&# 48;", "&")
+ end
+
+ def test_character_reference_decimal_control_character
+ # U+0008 BACKSPACE
+ assert_check_failed("", "")
+ end
+
+ def test_character_reference_format_hex_0x
+ # U+0041 LATIN CAPITAL LETTER A
+ assert_check_failed("�x41;", "�x41;")
+ end
+
+ def test_character_reference_format_hex_00x
+ # U+0041 LATIN CAPITAL LETTER A
+ assert_check_failed("�x41;", "�x41;")
+ end
+
+ def test_character_reference_hex_garbage_at_the_end
+ # U+0030 DIGIT ZERO
+ assert_check_failed("Hx;", "&")
+ end
+
+ def test_character_reference_hex_space_at_the_start
+ # U+0030 DIGIT ZERO
+ assert_check_failed("&#x 30;", "&")
+ end
+
+ def test_character_reference_hex_surrogate_block
+ # U+0D800 SURROGATE PAIR
+ assert_check_failed("�", "�")
+ end
+
+ def test_entity_name_non_ascii_symbol
+ # U+00BF INVERTED QUESTION MARK
+ assert_check_failed("&\u00BF;", "&")
+ end
+
+ def test_entity_name_new_line
+ # U+0026 AMPERSAND
+ assert_check_failed("&\namp\nx;", "&")
+ end
+ end
+ end
+end
diff --git a/test/rexml/test_ticket_80.rb b/test/rexml/test_ticket_80.rb
index ab6a57efaf..daebdc5972 100644
--- a/test/rexml/test_ticket_80.rb
+++ b/test/rexml/test_ticket_80.rb
@@ -7,9 +7,6 @@
# copy: (C) CopyLoose 2006 Bib Development Team <bib-devel>at<uberdev>dot<org>
#------------------------------------------------------------------------------
-require 'test/unit'
-require 'rexml/document'
-
module REXMLTests
class Ticket80 < Test::Unit::TestCase
diff --git a/test/rexml/test_validation_rng.rb b/test/rexml/test_validation_rng.rb
index b5b50450e0..4872396b84 100644
--- a/test/rexml/test_validation_rng.rb
+++ b/test/rexml/test_validation_rng.rb
@@ -1,7 +1,5 @@
# frozen_string_literal: false
-require "test/unit/testcase"
-require "rexml/document"
require "rexml/validation/relaxng"
module REXMLTests
@@ -9,7 +7,7 @@ class RNGValidation < Test::Unit::TestCase
include REXML
def test_validate
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -26,7 +24,7 @@ def test_validate
</element>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
no_error( validator, %q{<A><B><C X="x"><E/><E/></C><D/></B></A>} )
@@ -35,7 +33,7 @@ def test_validate
def test_sequence
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -47,7 +45,7 @@ def test_sequence
</element>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B><C/><C/><D/></B></A>} )
@@ -58,7 +56,7 @@ def test_sequence
def test_choice
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -72,7 +70,7 @@ def test_choice
</choice>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B><C/><D/></B></A>} )
@@ -81,7 +79,7 @@ def test_choice
end
def test_optional
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -92,7 +90,7 @@ def test_optional
</optional>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
no_error( validator, %q{<A><B/></A>} )
@@ -102,7 +100,7 @@ def test_optional
end
def test_zero_or_more
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -113,7 +111,7 @@ def test_zero_or_more
</zeroOrMore>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
no_error( validator, %q{<A><B/></A>} )
no_error( validator, %q{<A><B><C/></B></A>} )
@@ -121,7 +119,7 @@ def test_zero_or_more
error( validator, %q{<A><B><D/></B></A>} )
error( validator, %q{<A></A>} )
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -135,7 +133,7 @@ def test_zero_or_more
</zeroOrMore>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
no_error( validator, %q{<A><B/></A>} )
@@ -145,7 +143,7 @@ def test_zero_or_more
end
def test_one_or_more
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -156,7 +154,7 @@ def test_one_or_more
</oneOrMore>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -167,13 +165,13 @@ def test_one_or_more
end
def test_attribute
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<attribute name="X"/>
<attribute name="Y"/>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -183,7 +181,7 @@ def test_attribute
end
def test_choice_attributes
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<choice>
@@ -191,7 +189,7 @@ def test_choice_attributes
<attribute name="Y"/>
</choice>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A X="1" Y="1"/>} )
@@ -201,7 +199,7 @@ def test_choice_attributes
end
def test_choice_attribute_element
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<choice>
@@ -209,7 +207,7 @@ def test_choice_attribute_element
<element name="B"/>
</choice>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A X="1"><B/></A>} )
@@ -219,12 +217,12 @@ def test_choice_attribute_element
end
def test_empty
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<empty/>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -233,12 +231,12 @@ def test_empty
end
def test_text_val
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<text/>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -247,7 +245,7 @@ def test_text_val
end
def test_choice_text
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<choice>
@@ -255,7 +253,7 @@ def test_choice_text
<text/>
</choice>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/>Text</A>} )
@@ -265,7 +263,7 @@ def test_choice_text
end
def test_group
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<choice>
@@ -276,7 +274,7 @@ def test_group
</group>
</choice>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/><C/></A>} )
@@ -284,7 +282,7 @@ def test_group
no_error( validator, %q{<A><B/></A>} )
no_error( validator, %q{<A><C/><D/></A>} )
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B"/>
@@ -293,7 +291,7 @@ def test_group
<element name="D"/>
</group>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/><C/></A>} )
@@ -304,14 +302,14 @@ def test_group
def test_value
# Values as text nodes
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
<value>VaLuE</value>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B>X</B></A>} )
@@ -319,7 +317,7 @@ def test_value
no_error( validator, %q{<A><B>VaLuE</B></A>} )
# Values as text nodes, via choice
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -329,7 +327,7 @@ def test_value
</choice>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -338,14 +336,14 @@ def test_value
no_error( validator, %q{<A><B>Option 2</B></A>} )
# Attribute values
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<attribute name="B">
<value>VaLuE</value>
</attribute>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A/>} )
@@ -354,7 +352,7 @@ def test_value
no_error( validator, %q{<A B="VaLuE"/>} )
# Attribute values via choice
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<attribute name="B">
@@ -364,7 +362,7 @@ def test_value
</choice>
</attribute>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A B=""/>} )
@@ -374,7 +372,7 @@ def test_value
end
def test_interleave
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -385,7 +383,7 @@ def test_interleave
</interleave>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B><C/></B></A>} )
@@ -398,7 +396,7 @@ def test_interleave
end
def test_mixed
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -407,7 +405,7 @@ def test_mixed
</mixed>
</element>
</element>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
no_error( validator, %q{<A><B>Text<D/></B></A>} )
@@ -415,7 +413,7 @@ def test_mixed
end
def test_ref_sequence
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -431,7 +429,7 @@ def test_ref_sequence
</element>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
no_error( validator, %q{<A><B X=''/><B X=''/></A>} )
@@ -439,7 +437,7 @@ def test_ref_sequence
end
def test_ref_choice
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -455,7 +453,7 @@ def test_ref_choice
<element name="C"/>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><D/></A>} )
@@ -463,7 +461,7 @@ def test_ref_choice
no_error( validator, %q{<A><B/></A>} )
no_error( validator, %q{<A><C/></A>} )
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -479,7 +477,7 @@ def test_ref_choice
</choice>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><D/></A>} )
@@ -487,7 +485,7 @@ def test_ref_choice
no_error( validator, %q{<A><B/></A>} )
no_error( validator, %q{<A><C/></A>} )
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -504,7 +502,7 @@ def test_ref_choice
<element name="C"/>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/><C/></A>} )
@@ -515,7 +513,7 @@ def test_ref_choice
def test_ref_zero_plus
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -532,7 +530,7 @@ def test_ref_zero_plus
</element>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -540,7 +538,7 @@ def test_ref_zero_plus
no_error( validator, %q{<A><B X=''/></A>} )
no_error( validator, %q{<A><B X=''/><B X=''/><B X=''/></A>} )
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -557,7 +555,7 @@ def test_ref_zero_plus
</zeroOrMore>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -568,7 +566,7 @@ def test_ref_zero_plus
def test_ref_one_plus
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -585,7 +583,7 @@ def test_ref_one_plus
</element>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -593,7 +591,7 @@ def test_ref_one_plus
no_error( validator, %q{<A><B X=''/></A>} )
no_error( validator, %q{<A><B X=''/><B X=''/><B X=''/></A>} )
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -610,7 +608,7 @@ def test_ref_one_plus
</oneOrMore>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -620,7 +618,7 @@ def test_ref_one_plus
end
def test_ref_interleave
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -636,7 +634,7 @@ def test_ref_interleave
<element name="C"/>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -645,7 +643,7 @@ def test_ref_interleave
no_error( validator, %q{<A><B/><C/></A>} )
no_error( validator, %q{<A><C/><B/></A>} )
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -661,7 +659,7 @@ def test_ref_interleave
</interleave>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -670,7 +668,7 @@ def test_ref_interleave
no_error( validator, %q{<A><B/><C/></A>} )
no_error( validator, %q{<A><C/><B/></A>} )
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -689,7 +687,7 @@ def test_ref_interleave
<element name="C"/>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A><B/></A>} )
@@ -700,7 +698,7 @@ def test_ref_interleave
end
def test_ref_recurse
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -717,7 +715,7 @@ def test_ref_recurse
</element>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
error( validator, %q{<A></A>} )
@@ -726,7 +724,7 @@ def test_ref_recurse
end
def test_ref_optional
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -742,7 +740,7 @@ def test_ref_optional
</element>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
no_error( validator, %q{<A></A>} )
@@ -750,7 +748,7 @@ def test_ref_optional
error( validator, %q{<A><B/><B/></A>} )
error( validator, %q{<A><C/></A>} )
- rng = %q{
+ rng = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -766,7 +764,7 @@ def test_ref_optional
</optional>
</define>
</grammar>
- }
+ XML
validator = REXML::Validation::RelaxNG.new( rng )
no_error( validator, %q{<A></A>} )
diff --git a/test/rexml/test_xml_declaration.rb b/test/rexml/test_xml_declaration.rb
index a4d97c41d0..6a1f4df053 100644
--- a/test/rexml/test_xml_declaration.rb
+++ b/test/rexml/test_xml_declaration.rb
@@ -1,20 +1,16 @@
-# -*- coding: utf-8 -*-
# frozen_string_literal: false
#
# Created by Henrik Mårtensson on 2007-02-18.
# Copyright (c) 2007. All rights reserved.
-require "rexml/document"
-require "test/unit"
-
module REXMLTests
class TestXmlDeclaration < Test::Unit::TestCase
def setup
- xml = <<-'END_XML'
+ xml = <<~XML
<?xml encoding= 'UTF-8' standalone='yes'?>
<root>
</root>
- END_XML
+ XML
@doc = REXML::Document.new xml
@root = @doc.root
@xml_declaration = @doc.children[0]
@@ -32,5 +28,18 @@ def test_has_sibling
assert_kind_of(REXML::XMLDecl, @root.previous_sibling.previous_sibling)
assert_kind_of(REXML::Element, @xml_declaration.next_sibling.next_sibling)
end
+
+ def test_write_prologue_quote
+ @doc.context[:prologue_quote] = :quote
+ assert_equal("<?xml version=\"1.0\" " +
+ "encoding=\"UTF-8\" standalone=\"yes\"?>",
+ @xml_declaration.to_s)
+ end
+
+ def test_is_writethis_attribute_copied_by_clone
+ assert_equal(true, @xml_declaration.clone.writethis)
+ @xml_declaration.nowrite
+ assert_equal(false, @xml_declaration.clone.writethis)
+ end
end
end
diff --git a/test/rexml/xpath/test_attribute.rb b/test/rexml/xpath/test_attribute.rb
index 9304db4e0d..b778ff81f8 100644
--- a/test/rexml/xpath/test_attribute.rb
+++ b/test/rexml/xpath/test_attribute.rb
@@ -1,13 +1,11 @@
# frozen_string_literal: false
-require 'test/unit'
-require 'rexml/document'
module REXMLTests
class TestXPathAttribute < Test::Unit::TestCase
def setup
@xml = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
-<root>
+<root xmlns="http://example.com/">
<child name="one">child1</child>
<child name="two">child2</child>
<child name="three">child3</child>
@@ -26,5 +24,13 @@ def test_xpath_each
children = REXML::XPath.each(@document, "/root/child[@name='two']")
assert_equal(["child2"], children.collect(&:text))
end
+
+ def test_no_namespace
+ children = REXML::XPath.match(@document,
+ "/root/child[@nothing:name='two']",
+ "" => "http://example.com/",
+ "nothing" => "")
+ assert_equal(["child2"], children.collect(&:text))
+ end
end
end
diff --git a/test/rexml/xpath/test_axis_preceding_sibling.rb b/test/rexml/xpath/test_axis_preceding_sibling.rb
index 5842c6bc50..9c44ad63cc 100644
--- a/test/rexml/xpath/test_axis_preceding_sibling.rb
+++ b/test/rexml/xpath/test_axis_preceding_sibling.rb
@@ -1,6 +1,4 @@
# frozen_string_literal: false
-require "test/unit/testcase"
-require "rexml/document"
module REXMLTests
class TestXPathAxisPredcedingSibling < Test::Unit::TestCase
diff --git a/test/rexml/xpath/test_axis_self.rb b/test/rexml/xpath/test_axis_self.rb
new file mode 100644
index 0000000000..4e422f54bf
--- /dev/null
+++ b/test/rexml/xpath/test_axis_self.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: false
+
+module REXMLTests
+ class TestXPathAxisSelf < Test::Unit::TestCase
+ def test_only
+ doc = REXML::Document.new("<root><child/></root>")
+ assert_equal([doc.root],
+ REXML::XPath.match(doc.root, "."))
+ end
+
+ def test_have_predicate
+ doc = REXML::Document.new("<root><child/></root>")
+ error = assert_raise(REXML::ParseException) do
+ REXML::XPath.match(doc.root, ".[child]")
+ end
+ assert_equal("Garbage component exists at the end: <[child]>: <.[child]>",
+ error.message)
+ end
+ end
+end
diff --git a/test/rexml/xpath/test_base.rb b/test/rexml/xpath/test_base.rb
index 5079fdd75a..771cc48c58 100644
--- a/test/rexml/xpath/test_base.rb
+++ b/test/rexml/xpath/test_base.rb
@@ -1,11 +1,10 @@
# frozen_string_literal: false
-require_relative "../rexml_test_utils"
-require "rexml/document"
+require_relative "helper"
module REXMLTests
class TestXPathBase < Test::Unit::TestCase
- include REXMLTestUtils
+ include Helper::Fixture
include REXML
SOURCE = <<-EOF
<a id='1'>
@@ -369,11 +368,15 @@ def test_complex
assert_equal 2, c
end
+ def match(xpath)
+ XPath.match(@@doc, xpath).collect(&:to_s)
+ end
+
def test_grouping
- t = XPath.first( @@doc, "a/d/*[name()='d' and (name()='f' or name()='q')]" )
- assert_nil t
- t = XPath.first( @@doc, "a/d/*[(name()='d' and name()='f') or name()='q']" )
- assert_equal 'q', t.name
+ assert_equal([],
+ match("a/d/*[name()='d' and (name()='f' or name()='q')]"))
+ assert_equal(["<q id='19'/>"],
+ match("a/d/*[(name()='d' and name()='f') or name()='q']"))
end
def test_preceding
@@ -450,6 +453,46 @@ def test_following
# puts results
#end
+ def test_nested_predicates
+ doc = Document.new <<-EOF
+ <div>
+ <div>
+ <test>ab</test>
+ <test>cd</test>
+ </div>
+ <div>
+ <test>ef</test>
+ <test>gh</test>
+ </div>
+ <div>
+ <test>hi</test>
+ </div>
+ </div>
+ EOF
+
+ matches = XPath.match(doc, '(/div/div/test[0])').map(&:text)
+ assert_equal [], matches
+ matches = XPath.match(doc, '(/div/div/test[1])').map(&:text)
+ assert_equal ["ab", "ef", "hi"], matches
+ matches = XPath.match(doc, '(/div/div/test[2])').map(&:text)
+ assert_equal ["cd", "gh"], matches
+ matches = XPath.match(doc, '(/div/div/test[3])').map(&:text)
+ assert_equal [], matches
+
+ matches = XPath.match(doc, '(/div/div/test[1])[1]').map(&:text)
+ assert_equal ["ab"], matches
+ matches = XPath.match(doc, '(/div/div/test[1])[2]').map(&:text)
+ assert_equal ["ef"], matches
+ matches = XPath.match(doc, '(/div/div/test[1])[3]').map(&:text)
+ assert_equal ["hi"], matches
+ matches = XPath.match(doc, '(/div/div/test[2])[1]').map(&:text)
+ assert_equal ["cd"], matches
+ matches = XPath.match(doc, '(/div/div/test[2])[2]').map(&:text)
+ assert_equal ["gh"], matches
+ matches = XPath.match(doc, '(/div/div/test[2])[3]').map(&:text)
+ assert_equal [], matches
+ end
+
# Contributed by Mike Stok
def test_starts_with
source = <<-EOF
@@ -610,7 +653,7 @@ def test_comparisons
source = "<a><b id='1'/><b id='2'/><b id='3'/></a>"
doc = REXML::Document.new(source)
- # NOTE TO SER: check that number() is required
+ # NOTE: check that number() is required
assert_equal 2, REXML::XPath.match(doc, "//b[number(@id) > 1]").size
assert_equal 3, REXML::XPath.match(doc, "//b[number(@id) >= 1]").size
assert_equal 1, REXML::XPath.match(doc, "//b[number(@id) <= 1]").size
@@ -632,29 +675,36 @@ def test_spaces
<c id='a'/>
</b>
<c id='b'/>
+ <c id='c'/>
+ <c/>
</a>")
- assert_equal( 1, REXML::XPath.match(doc,
- "//*[local-name()='c' and @id='b']").size )
- assert_equal( 1, REXML::XPath.match(doc,
- "//*[ local-name()='c' and @id='b' ]").size )
- assert_equal( 1, REXML::XPath.match(doc,
- "//*[ local-name() = 'c' and @id = 'b' ]").size )
- assert_equal( 1,
- REXML::XPath.match(doc, '/a/c[@id]').size )
- assert_equal( 1,
- REXML::XPath.match(doc, '/a/c[(@id)]').size )
- assert_equal( 1,
- REXML::XPath.match(doc, '/a/c[ @id ]').size )
- assert_equal( 1,
- REXML::XPath.match(doc, '/a/c[ (@id) ]').size )
- assert_equal( 1,
- REXML::XPath.match(doc, '/a/c[( @id )]').size )
- assert_equal( 1, REXML::XPath.match(doc.root,
- '/a/c[ ( @id ) ]').size )
- assert_equal( 1, REXML::XPath.match(doc,
- '/a/c [ ( @id ) ] ').size )
- assert_equal( 1, REXML::XPath.match(doc,
- ' / a / c [ ( @id ) ] ').size )
+ match = lambda do |xpath|
+ REXML::XPath.match(doc, xpath).collect(&:to_s)
+ end
+ assert_equal(["<c id='b'/>"],
+ match.call("//*[local-name()='c' and @id='b']"))
+ assert_equal(["<c id='b'/>"],
+ match.call("//*[ local-name()='c' and @id='b' ]"))
+ assert_equal(["<c id='b'/>"],
+ match.call("//*[ local-name() = 'c' and @id = 'b' ]"))
+ assert_equal(["<c id='b'/>", "<c id='c'/>"],
+ match.call('/a/c[@id]'))
+ assert_equal(["<c id='b'/>", "<c id='c'/>"],
+ match.call('/a/c[(@id)]'))
+ assert_equal(["<c id='b'/>", "<c id='c'/>"],
+ match.call('/a/c[ @id ]'))
+ assert_equal(["<c id='b'/>", "<c id='c'/>"],
+ match.call('/a/c[ (@id) ]'))
+ assert_equal(["<c id='b'/>", "<c id='c'/>"],
+ match.call('/a/c[( @id )]'))
+ assert_equal(["<c id='b'/>", "<c id='c'/>"],
+ match.call('/a/c[ ( @id ) ]'))
+ assert_equal(["<c id='b'/>", "<c id='c'/>"],
+ match.call('/a/c [ ( @id ) ] '))
+ assert_equal(["<c id='b'/>", "<c id='c'/>"],
+ match.call(' / a / c [ ( @id ) ] '))
+ assert_equal(["<c id='b'/>", "<c id='c'/>"],
+ match.call('/ a / child:: c [( @id )] /'))
end
def test_text_nodes
@@ -692,11 +742,22 @@ def test_auto_string_value
end
def test_ordering
- source = "<a><b><c id='1'/><c id='2'/></b><b><d id='1'/><d id='2'/></b></a>"
+ source = <<-XML
+<a>
+ <b>
+ <c id='1'/>
+ <c id='2'/>
+ </b>
+ <b>
+ <d id='3'/>
+ <d id='4'/>
+ </b>
+</a>
+ XML
d = REXML::Document.new( source )
r = REXML::XPath.match( d, %q{/a/*/*[1]} )
- assert_equal( 1, r.size )
- r.each { |el| assert_equal( '1', el.attribute('id').value ) }
+ assert_equal(["1", "3"],
+ r.collect {|element| element.attribute("id").value})
end
def test_descendant_or_self_ordering
@@ -830,31 +891,44 @@ def test_a_star_star_one
</a>
EOL
d = REXML::Document.new( string )
- c1 = XPath.match( d, '/a/*/*[1]' )
- assert_equal( 1, c1.length )
- assert_equal( 'c1', c1[0].name )
+ cs = XPath.match( d, '/a/*/*[1]' )
+ assert_equal(["c1", "c2"], cs.collect(&:name))
end
def test_sum
- d = Document.new("<a>"+
- "<b>1</b><b>2</b><b>3</b>"+
- "<c><d>1</d><d>2</d></c>"+
- "<e att='1'/><e att='2'/>"+
- "</a>")
-
- for v,p in [[6, "sum(/a/b)"],
- [9, "sum(//b | //d)"],
- [3, "sum(/a/e/@*)"] ]
- assert_equal( v, XPath::match( d, p ).first )
- end
+ d = Document.new(<<-XML)
+<a>
+ <b>1</b>
+ <b>2</b>
+ <b>3</b>
+ <c>
+ <d>1</d>
+ <d>2</d>
+ </c>
+ <e att='1'/>
+ <e att='2'/>
+</a>
+ XML
+
+ assert_equal([6], XPath::match(d, "sum(/a/b)"))
+ assert_equal([9], XPath::match(d, "sum(//b | //d)"))
+ assert_equal([3], XPath::match(d, "sum(/a/e/@*)"))
end
def test_xpath_namespace
- d = REXML::Document.new("<tag1 xmlns='ns1'><tag2 xmlns='ns2'/><tada>xa</tada></tag1>")
- x = d.root
- num = 0
- x.each_element('tada') { num += 1 }
- assert_equal(1, num)
+ d = REXML::Document.new(<<-XML)
+<tag1 xmlns='ns1'>
+ <tag2 xmlns='ns2'/>
+ <tada>xa</tada>
+ <tada xmlns=''>xb</tada>
+</tag1>
+ XML
+ actual = []
+ d.root.each_element('tada') do |element|
+ actual << element.to_s
+ end
+ assert_equal(["<tada>xa</tada>", "<tada xmlns=''>xb</tada>"],
+ actual)
end
def test_ticket_39
@@ -990,7 +1064,7 @@ def test_ticket_59
</a>"
d = Document.new(data)
res = d.elements.to_a( "//c" ).collect {|e| e.attributes['id'].to_i}
- assert_equal( res, res.sort )
+ assert_equal((1..12).to_a, res)
end
def ticket_61_fixture(doc, xpath)
diff --git a/test/rexml/xpath/test_compare.rb b/test/rexml/xpath/test_compare.rb
new file mode 100644
index 0000000000..11d11e55be
--- /dev/null
+++ b/test/rexml/xpath/test_compare.rb
@@ -0,0 +1,252 @@
+# frozen_string_literal: false
+
+module REXMLTests
+ class TestXPathCompare < Test::Unit::TestCase
+ def match(xml, xpath)
+ document = REXML::Document.new(xml)
+ REXML::XPath.match(document, xpath)
+ end
+
+ class TestEqual < self
+ class TestNodeSet < self
+ def test_boolean_true
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child/>
+ <child/>
+</root>
+ XML
+ assert_equal([true],
+ match(xml, "/root/child=true()"))
+ end
+
+ def test_boolean_false
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+</root>
+ XML
+ assert_equal([false],
+ match(xml, "/root/child=true()"))
+ end
+
+ def test_number_true
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child>100</child>
+ <child>200</child>
+</root>
+ XML
+ assert_equal([true],
+ match(xml, "/root/child=100"))
+ end
+
+ def test_number_false
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child>100</child>
+ <child>200</child>
+</root>
+ XML
+ assert_equal([false],
+ match(xml, "/root/child=300"))
+ end
+
+ def test_string_true
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child>text</child>
+ <child>string</child>
+</root>
+ XML
+ assert_equal([true],
+ match(xml, "/root/child='string'"))
+ end
+
+ def test_string_false
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child>text</child>
+ <child>string</child>
+</root>
+ XML
+ assert_equal([false],
+ match(xml, "/root/child='nonexistent'"))
+ end
+ end
+
+ class TestBoolean < self
+ def test_number_true
+ xml = "<root/>"
+ assert_equal([true],
+ match(xml, "true()=1"))
+ end
+
+ def test_number_false
+ xml = "<root/>"
+ assert_equal([false],
+ match(xml, "true()=0"))
+ end
+
+ def test_string_true
+ xml = "<root/>"
+ assert_equal([true],
+ match(xml, "true()='string'"))
+ end
+
+ def test_string_false
+ xml = "<root/>"
+ assert_equal([false],
+ match(xml, "true()=''"))
+ end
+ end
+
+ class TestNumber < self
+ def test_string_true
+ xml = "<root/>"
+ assert_equal([true],
+ match(xml, "1='1'"))
+ end
+
+ def test_string_false
+ xml = "<root/>"
+ assert_equal([false],
+ match(xml, "1='2'"))
+ end
+ end
+ end
+
+ class TestGreaterThan < self
+ class TestNodeSet < self
+ def test_boolean_truex
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child/>
+</root>
+ XML
+ assert_equal([true],
+ match(xml, "/root/child>false()"))
+ end
+
+ def test_boolean_false
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child/>
+</root>
+ XML
+ assert_equal([false],
+ match(xml, "/root/child>true()"))
+ end
+
+ def test_number_true
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child>100</child>
+ <child>200</child>
+</root>
+ XML
+ assert_equal([true],
+ match(xml, "/root/child>199"))
+ end
+
+ def test_number_false
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child>100</child>
+ <child>200</child>
+</root>
+ XML
+ assert_equal([false],
+ match(xml, "/root/child>200"))
+ end
+
+ def test_string_true
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child>100</child>
+ <child>200</child>
+</root>
+ XML
+ assert_equal([true],
+ match(xml, "/root/child>'199'"))
+ end
+
+ def test_string_false
+ xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+ <child>100</child>
+ <child>200</child>
+</root>
+ XML
+ assert_equal([false],
+ match(xml, "/root/child>'200'"))
+ end
+ end
+
+ class TestBoolean < self
+ def test_string_true
+ xml = "<root/>"
+ assert_equal([true],
+ match(xml, "true()>'0'"))
+ end
+
+ def test_string_false
+ xml = "<root/>"
+ assert_equal([false],
+ match(xml, "true()>'1'"))
+ end
+ end
+
+ class TestNumber < self
+ def test_boolean_true
+ xml = "<root/>"
+ assert_equal([true],
+ match(xml, "true()>0"))
+ end
+
+ def test_number_false
+ xml = "<root/>"
+ assert_equal([false],
+ match(xml, "true()>1"))
+ end
+
+ def test_string_true
+ xml = "<root/>"
+ assert_equal([true],
+ match(xml, "1>'0'"))
+ end
+
+ def test_string_false
+ xml = "<root/>"
+ assert_equal([false],
+ match(xml, "1>'1'"))
+ end
+ end
+
+ class TestString < self
+ def test_string_true
+ xml = "<root/>"
+ assert_equal([true],
+ match(xml, "'1'>'0'"))
+ end
+
+ def test_string_false
+ xml = "<root/>"
+ assert_equal([false],
+ match(xml, "'1'>'1'"))
+ end
+ end
+ end
+ end
+end
diff --git a/test/rexml/xpath/test_node.rb b/test/rexml/xpath/test_node.rb
index e0e958e70f..742bfbbab6 100644
--- a/test/rexml/xpath/test_node.rb
+++ b/test/rexml/xpath/test_node.rb
@@ -1,10 +1,6 @@
# -*- coding: utf-8 -*-
# frozen_string_literal: false
-require_relative "../rexml_test_utils"
-
-require "rexml/document"
-
module REXMLTests
class TestXPathNode < Test::Unit::TestCase
def matches(xml, xpath)
diff --git a/test/rexml/xpath/test_predicate.rb b/test/rexml/xpath/test_predicate.rb
index ce1aaa324b..278e3765b6 100644
--- a/test/rexml/xpath/test_predicate.rb
+++ b/test/rexml/xpath/test_predicate.rb
@@ -1,13 +1,12 @@
# frozen_string_literal: false
-require "test/unit/testcase"
-require "rexml/document"
+
require "rexml/xpath"
require "rexml/parsers/xpathparser"
module REXMLTests
class TestXPathPredicate < Test::Unit::TestCase
include REXML
- SRC=<<-EOL
+ SRC=<<~EOL
<article>
<section role="subdivision" id="1">
<para>free flowing text.</para>
@@ -29,6 +28,15 @@ def setup
end
+ def test_predicate_only
+ error = assert_raise(REXML::ParseException) do
+ do_path("[article]")
+ end
+ assert_equal("Garbage component exists at the end: " +
+ "<[article]>: <[article]>",
+ error.message)
+ end
+
def test_predicates_parent
path = '//section[../self::section[@role="division"]]'
m = do_path( path )
diff --git a/test/rexml/xpath/test_text.rb b/test/rexml/xpath/test_text.rb
index 7222388e1b..dccc4c83c0 100644
--- a/test/rexml/xpath/test_text.rb
+++ b/test/rexml/xpath/test_text.rb
@@ -1,6 +1,5 @@
# frozen_string_literal: false
-require 'test/unit'
-require 'rexml/document'
+
require 'rexml/element'
require 'rexml/xpath'
