- @value = @normalized = Text::normalize( @value, doctype )

- @unnormalized if @unnormalized

- @value = @unnormalized = Text::unnormalize( @value, doctype )

- # Represents an XML DOCTYPE declaration; that is, the contents of <!DOCTYPE

- # ... >. DOCTYPES can be used to declare the DTD of a document, as well as

- # being used to declare entities used in the document.

- class DocType < Parent

- include XMLTokens

- START = "<!DOCTYPE"

- STOP = ">"

- SYSTEM = "SYSTEM"

- PUBLIC = "PUBLIC"

- DEFAULT_ENTITIES = {

- 'gt'=>EntityConst::GT,

- 'lt'=>EntityConst::LT,

- 'quot'=>EntityConst::QUOT,

- "apos"=>EntityConst::APOS

- }

-

- # name is the name of the doctype

- # external_id is the referenced DTD, if given

- attr_reader :name, :external_id, :entities, :namespaces

-

- # Constructor

- #

- # dt = DocType.new( 'foo', '-//I/Hate/External/IDs' )

- # # <!DOCTYPE foo '-//I/Hate/External/IDs'>

- # dt = DocType.new( doctype_to_clone )

- # # Incomplete. Shallow clone of doctype

- def initialize( first, parent=nil )

- @entities = DEFAULT_ENTITIES

- @long_name = @uri = nil

- if first.kind_of? String

- super()

- @name = first

- @external_id = parent

- elsif first.kind_of? DocType

- super( parent )

- @name = first.name

- @external_id = first.external_id

- elsif first.kind_of? Array

- super( parent )

- @name = first[0]

- @external_id = first[1]

- @long_name = first[2]

- @uri = first[3]

- end

- end

-

- def node_type

- :doctype

- end

-

- def attributes_of element

- rv = []

- each do |child|

- child.each do |key,val|

- rv << Attribute.new(key,val)

- end if child.kind_of? AttlistDecl and child.element_name == element

- end

- rv

- end

-

- def attribute_of element, attribute

- att_decl = find do |child|

- child.kind_of? AttlistDecl and

- child.element_name == element and

- child.include? attribute

- end

- return nil unless att_decl

- att_decl[attribute]

- end

-

- def clone

- DocType.new self

- end

-

- # output::

- # Where to write the string

- # indent::

- # An integer. If -1, no indenting will be used; otherwise, the

- # indentation will be this number of spaces, and children will be

- # indented an additional amount.

- # transitive::

- # If transitive is true and indent is >= 0, then the output will be

- # pretty-printed in such a way that the added whitespace does not affect

- # the absolute *value* of the document -- that is, it leaves the value

- # and number of Text nodes in the document unchanged.

- # ie_hack::

- # Internet Explorer is the worst piece of crap to have ever been

- # written, with the possible exception of Windows itself. Since IE is

- # unable to parse proper XML, we have to provide a hack to generate XML

- # that IE's limited abilities can handle. This hack inserts a space

- # before the /> on empty tags.

- #

- def write( output, indent=0, transitive=false, ie_hack=false )

- indent( output, indent )

- output << START

- output << ' '

- output << @name

- output << " #@external_id" if @external_id

- output << " #@long_name" if @long_name

- output << " #@uri" if @uri

- unless @children.empty?

- next_indent = indent + 1

- output << ' ['

- child = nil # speed

- @children.each { |child|

- output << "\n"

- child.write( output, next_indent )

- }

- output << "\n"

- #output << ' '*next_indent

- output << "]"

- end

- output << STOP

- end

- def entity( name )

- @entities[name].unnormalized if @entities[name]

- end

-

- def add child

- super(child)

- @entities = DEFAULT_ENTITIES.clone if @entities == DEFAULT_ENTITIES

- @entities[ child.name ] = child if child.kind_of? Entity

- end

- end

-

- # We don't really handle any of these since we're not a validating

- # parser, so we can be pretty dumb about them. All we need to be able

- # to do is spew them back out on a write()

-

- # This is an abstract class. You never use this directly; it serves as a

- # parent class for the specific declarations.

- class Declaration < Child

- def initialize src

- super()

- @string = src

- end

-

- def to_s

- @string+'>'

- end

-

- def write( output, indent )

- output << (' '*indent) if indent > 0

- output << to_s

- end

- end

-

- public

- class ElementDecl < Declaration

- def initialize( src )

- super

- end

- end

-

- class ExternalEntity < Child

- def initialize( src )

- super()

- @entity = src

- end

- def to_s

- @entity

- end

- def write( output, indent )

- output << @entity

- output << "\n"

- end

- end

-

- class NotationDecl < Child

- def initialize name, middle, rest

- @name = name

- @middle = middle

- @rest = rest

- end

-

- def to_s

- "<!NOTATION #@name '#@middle #@rest'>"

- end

-

- def write( output, indent=-1 )

- output << (' '*indent) if indent > 0

- output << to_s

- end

- end

- # declaration for you. See |DECLARATION| and |write|.

- class Document < Element

- # A convenient default XML declaration. If you want an XML declaration,

- # the easiest way to add one is mydoc << Document::DECLARATION

- 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.

- # NOTE that I'm not sure what the context is for; I cloned it out of

- # the Electric XML API (in which it also seems to do nothing), and it

- # is now legacy. It may do something, someday... it may disappear.

- def initialize( source = nil, context = {} )

- super()

- @context = context

- return if source.nil?

- if source.kind_of? Document

- @context = source.context

- super source

- else

- build( source )

- end

- end

- # Should be obvious

- def clone

- Document.new self

- end

-

- # According to the XML spec, a root node has no expanded name

- 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

- def add( child )

- if child.kind_of? XMLDecl

- @children.unshift child

- elsif child.kind_of? DocType

- if @children[0].kind_of? XMLDecl

- @children[1,0] = child

- else

- @children.unshift child

- child.parent = self

- else

- rv = super

- raise "attempted adding second root element to document" if @elements.size > 1

- rv

- end

- end

- alias :<< :add

-

- 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.

- def root

- end

-

- # @return the DocType child of the document, if one exists,

- # and nil otherwise.

- 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.

- def xml_decl

- rv = @children[0]

- end

-

- # @return the XMLDecl version of this document as a String.

- # If no XMLDecl has been set, returns the default version.

- def version

- xml_decl().version

- end

-

- # @return the XMLDecl encoding of this document as a String.

- # If no XMLDecl has been set, returns the default encoding.

- 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.

- def stand_alone?

- xml_decl().stand_alone?

- end

-

- # Write the XML tree out, optionally with indent. This writes out the

- # entire XML document, including XML declarations, doctype declarations,

- # and processing instructions (if any are given).

- # A controversial point is whether Document should always write the XML

- # declaration (<?xml version='1.0'?>) whether or not one is given by the

- # user (or source document). REXML does not write one if one was not

- # specified, because it adds unneccessary bandwidth to applications such

- # as XML-RPC.

- #

- #

- # output::

- # output an object which supports '<< string'; this is where the

- # document will be written.

- # indent::

- # An integer. If -1, no indenting will be used; otherwise, the

- # indentation will be this number of spaces, and children will be

- # indented an additional amount. Defaults to -1

- # transitive::

- # If transitive is true and indent is >= 0, then the output will be

- # pretty-printed in such a way that the added whitespace does not affect

- # the absolute *value* of the document -- that is, it leaves the value

- # and number of Text nodes in the document unchanged.

- # ie_hack::

- # Internet Explorer is the worst piece of crap to have ever been

- # written, with the possible exception of Windows itself. Since IE is

- # unable to parse proper XML, we have to provide a hack to generate XML

- # that IE's limited abilities can handle. This hack inserts a space

- # before the /> on empty tags. Defaults to false

- def write( output=$stdout, indent_level=-1, transitive=false, ie_hack=false )

- output = Output.new( output, xml_decl.encoding ) if xml_decl.encoding != "UTF-8" && !output.kind_of?(Output)

- @children.each { |node|

- indent( output, indent_level ) if node.node_type == :element

- if node.write( output, indent_level, transitive, ie_hack )

- output << "\n" unless indent_level<0 or node == @children[-1]

- }

- end

-

- def Document::parse_stream( source, listener )

- Parsers::StreamParser.new( source, listener ).parse

- end

- private

- def build( source )

- end

- end

- # If a Source, the source will be scanned and parsed for an Element,

- # and all child elements will be recursively parsed as well.

- prefix = self.prefix()

- rv = node.expanded_name

- module Encoding

- @encoding_methods = {}

- def self.register(enc, &block)

- @encoding_methods[enc] = block

- end

- def self.apply(obj, enc)

- @encoding_methods[enc][obj]

- end

- def self.encoding_method(enc)

- @encoding_methods[enc]

- end

- # Native, default format is UTF-8, so it is declared here rather than in

- # an encodings/ definition.

- UTF_8 = 'UTF-8'

- UTF_16 = 'UTF-16'

- UNILE = 'UNILE'

- # ID ---> Encoding name

- attr_reader :encoding

- def encoding=( enc )

- old_verbosity = $VERBOSE

- begin

- $VERBOSE = false

- return if defined? @encoding and enc == @encoding

- if enc

- raise ArgumentError, "Bad encoding name #{enc}" unless /\A[\w-]+\z/n =~ enc

- @encoding = enc.upcase.untaint

- else

- @encoding = UTF_8

- end

- err = nil

- [@encoding, "ICONV"].each do |enc|

- begin

- require File.join("rexml", "encodings", "#{enc}.rb")

- return Encoding.apply(self, enc)

- rescue LoadError, Exception => err

- end

- end

- puts err.message

- raise ArgumentError, "No decoder found for encoding #@encoding. Please install iconv."

- ensure

- $VERBOSE = old_verbosity

- end

- end

- def check_encoding str

- # We have to recognize UTF-16, LSB UTF-16, and UTF-8

- return UTF_16 if str[0] == 254 && str[1] == 255

- return UNILE if str[0] == 255 && str[1] == 254

- str =~ /^\s*<?xml\s*version=(['"]).*?\2\s*encoding=(["'])(.*?)\2/um

- return $1.upcase if $1

- return UTF_8

- end

- end

- if node_set.namespace

- yield node_set

- else

- return unless node_set.kind_of? Enumerable

- ruby_index = ruby_string.index(string(test))

- if ruby_index.nil?

- ""

- else

- ruby_string[ ruby_index+1..-1 ]

- end

- def write writer, indent_level=-1, transitive=false, ie_hack=false

- indent(writer, indent_level)

- # A parent has children, and has methods for accessing them. The Parent

- class Parent < Child

- include Enumerable

-

- # Constructor

- # @param parent if supplied, will be set as the parent of this object

- def initialize parent=nil

- super(parent)

- @children = []

- end

-

- def add( object )

- #puts "PARENT GOTS #{size} CHILDREN"

- object.parent = self

- @children << object

- #puts "PARENT NOW GOTS #{size} CHILDREN"

- object

- end

-

- alias :push :add

- alias :<< :push

-

- def unshift( object )

- object.parent = self

- @children.unshift object

- end

-

- def delete( object )

- return unless @children.include? object

- @children.delete object

- object.parent = nil

- end

-

- def each(&block)

- @children.each(&block)

- end

-

- def delete_if( &block )

- @children.delete_if(&block)

- end

-

- def delete_at( index )

- @children.delete_at index

- end

-

- def each_index( &block )

- @children.each_index(&block)

- end

-

- # Fetches a child at a given index

- # @param index the Integer index of the child to fetch

- def []( index )

- @children[index]

- end

-

- alias :each_child :each

-

-

-

- # Set an index entry. See Array.[]=

- # @param index the index of the element to set

- # @param opt either the object to set, or an Integer length

- # @param child if opt is an Integer, this is the child to set

- # @return the parent (self)

- def []=( *args )

- args[-1].parent = self

- @children[*args[0..-2]] = args[-1]

- end

-

- # Inserts an child before another child

- # @param child1 this is either an xpath or an Element. If an Element,

- # child2 will be inserted before child1 in the child list of the parent.

- # If an xpath, child2 will be inserted before the first child to match

- # the xpath.

- # @param child2 the child to insert

- # @return the parent (self)

- def insert_before( child1, child2 )

- if child1.kind_of? String

- child1 = XPath.first( self, child1 )

- child1.parent.insert_before child1, child2

- else

- ind = index(child1)

- child2.parent.delete(child2) if child2.parent

- @children[ind,0] = child2

- child2.parent = self

- end

- self

- end

-

- # Inserts an child after another child

- # @param child1 this is either an xpath or an Element. If an Element,

- # child2 will be inserted after child1 in the child list of the parent.

- # If an xpath, child2 will be inserted after the first child to match

- # the xpath.

- # @param child2 the child to insert

- # @return the parent (self)

- def insert_after( child1, child2 )

- if child1.kind_of? String

- child1 = XPath.first( self, child1 )

- child1.parent.insert_after child1, child2

- else

- ind = index(child1)+1

- child2.parent.delete(child2) if child2.parent

- @children[ind,0] = child2

- child2.parent = self

- end

- self

- end

-

- def to_a

- @children.dup

- end

-

- # Fetches the index of a given child

- # @param child the child to get the index of

- # @return the index of the child, or nil if the object is not a child

- # of this parent.

- def index( child )

- count = -1

- @children.find { |i| count += 1 ; i.hash == child.hash }

- count

- end

-

- # @return the number of children of this parent

- def size

- @children.size

- end

-

- # Replaces one child with another, making sure the nodelist is correct

- # @param to_replace the child to replace (must be a Child)

- # @param replacement the child to insert into the nodelist (must be a

- # Child)

- def replace_child( to_replace, replacement )

- ind = @children.index( to_replace )

- to_replace.parent = nil

- @children[ind,0] = replacement

- replacement.parent = self

- end

-

- # Deeply clones this object. This creates a complete duplicate of this

- # Parent, including all descendants.

- def deep_clone

- cl = clone()

- each do |child|

- if child.kind_of? Parent

- cl << child.deep_clone

- else

- cl << child.clone

- end

- end

- cl

- end

-

- alias :children :to_a

-

- def parent?

- true

- end

- end

- module Parsers

- # = Using the Pull Parser

- # <em>This API is experimental, and subject to change.</em>

- # parser = PullParser.new( "<a>text<b att='val'/>txet</a>" )

- # while parser.has_next?

- # res = parser.next

- # puts res[1]['att'] if res.start_tag? and res[0] == 'b'

- # end

- # See the PullEvent class for information on the content of the results.

- # The data is identical to the arguments passed for the various events to

- # the StreamListener API.

- #

- # Notice that:

- # parser = PullParser.new( "<a>BAD DOCUMENT" )

- # while parser.has_next?

- # res = parser.next

- # raise res[1] if res.error?

- # end

- #

- # Nat Price gave me some good ideas for the API.

- class BaseParser

- NCNAME_STR= '[\w:][\-\w\d.]*'

- NAME_STR= "(?:#{NCNAME_STR}:)?#{NCNAME_STR}"

- NAMECHAR = '[\-\w\d\.:]'

- NAME = "([\\w:]#{NAMECHAR}*)"

- NMTOKEN = "(?:#{NAMECHAR})+"

- NMTOKENS = "#{NMTOKEN}(\\s+#{NMTOKEN})*"

- REFERENCE = "(?:&#{NAME};|&#\\d+;|&#x[0-9a-fA-F]+;)"

- REFERENCE_RE = /#{REFERENCE}/

- DOCTYPE_START = /\A\s*<!DOCTYPE\s/um

- DOCTYPE_PATTERN = /\s*<!DOCTYPE\s+(.*?)(\[|>)/um

- ATTRIBUTE_PATTERN = /\s*(#{NAME_STR})\s*=\s*(["'])(.*?)\2/um

- COMMENT_START = /\A<!--/u

- COMMENT_PATTERN = /<!--(.*?)-->/um

- CDATA_START = /\A<!\[CDATA\[/u

- CDATA_END = /^\s*\]\s*>/um

- CDATA_PATTERN = /<!\[CDATA\[(.*?)\]\]>/um

- XMLDECL_START = /\A<\?xml\s/u;

- XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>*/um

- INSTRUCTION_START = /\A<\?/u

- INSTRUCTION_PATTERN = /<\?(.*?)(\s+.*?)?\?>/um

- TAG_MATCH = /^<((?>#{NAME_STR}))\s*((?>\s+#{NAME_STR}\s*=\s*(["']).*?\3)*)\s*(\/)?>/um

- CLOSE_MATCH = /^\s*<\/(#{NAME_STR})\s*>/um

- VERSION = /\bversion\s*=\s*["'](.*?)['"]/um

- ENCODING = /\bencoding=["'](.*?)['"]/um

- STANDALONE = /\bstandalone=["'](.*?)['"]/um

- ENTITY_START = /^\s*<!ENTITY/

- IDENTITY = /^([!\*\w\-]+)(\s+#{NCNAME_STR})?(\s+["'].*?['"])?(\s+['"].*?["'])?/u

- ELEMENTDECL_START = /^\s*<!ELEMENT/um

- ELEMENTDECL_PATTERN = /^\s*(<!ELEMENT.*?)>/um

- SYSTEMENTITY = /^\s*(%.*?;)\s*$/um

- ENUMERATION = "\\(\\s*#{NMTOKEN}(?:\\s*\\|\\s*#{NMTOKEN})*\\s*\\)"

- NOTATIONTYPE = "NOTATION\\s+\\(\\s*#{NAME}(?:\\s*\\|\\s*#{NAME})*\\s*\\)"

- ENUMERATEDTYPE = "(?:(?:#{NOTATIONTYPE})|(?:#{ENUMERATION}))"

- ATTTYPE = "(CDATA|ID|IDREF|IDREFS|ENTITY|ENTITIES|NMTOKEN|NMTOKENS|#{ENUMERATEDTYPE})"

- ATTVALUE = "(?:\"((?:[^<&\"]|#{REFERENCE})*)\")|(?:'((?:[^<&']|#{REFERENCE})*)')"

- DEFAULTDECL = "(#REQUIRED|#IMPLIED|(?:(#FIXED\\s+)?#{ATTVALUE}))"

- ATTDEF = "\\s+#{NAME}\\s+#{ATTTYPE}\\s+#{DEFAULTDECL}"

- ATTDEF_RE = /#{ATTDEF}/

- ATTLISTDECL_START = /^\s*<!ATTLIST/um

- ATTLISTDECL_PATTERN = /^\s*<!ATTLIST\s+#{NAME}(?:#{ATTDEF})*\s*>/um

- NOTATIONDECL_START = /^\s*<!NOTATION/um

- PUBLIC = /^\s*<!NOTATION\s+(\w[\-\w]*)\s+(PUBLIC)\s+((["']).*?\4)\s*>/um

- SYSTEM = /^\s*<!NOTATION\s+(\w[\-\w]*)\s+(SYSTEM)\s+((["']).*?\4)\s*>/um

- TEXT_PATTERN = /\A([^<]*)/um

- # Entity constants

- PUBIDCHAR = "\x20\x0D\x0Aa-zA-Z0-9\\-()+,./:=?;!*@$_%#"

- SYSTEMLITERAL = %Q{((?:"[^"]*")|(?:'[^']*'))}

- PUBIDLITERAL = %Q{("[#{PUBIDCHAR}']*"|'[#{PUBIDCHAR}]*')}

- EXTERNALID = "(?:(?:(SYSTEM)\\s+#{SYSTEMLITERAL})|(?:(PUBLIC)\\s+#{PUBIDLITERAL}\\s+#{SYSTEMLITERAL}))"

- NDATADECL = "\\s+NDATA\\s+#{NAME}"

- PEREFERENCE = "%#{NAME};"

- ENTITYVALUE = %Q{((?:"(?:[^%&"]|#{PEREFERENCE}|#{REFERENCE})*")|(?:'([^%&']|#{PEREFERENCE}|#{REFERENCE})*'))}

- PEDEF = "(?:#{ENTITYVALUE}|#{EXTERNALID})"

- ENTITYDEF = "(?:#{ENTITYVALUE}|(?:#{EXTERNALID}(#{NDATADECL})?))"

- PEDECL = "<!ENTITY\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>"

- GEDECL = "<!ENTITY\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"

- ENTITYDECL = /\s*(?:#{GEDECL})|(?:#{PEDECL})/um

- EREFERENCE = /&(?!#{NAME};)/

- DEFAULT_ENTITIES = {

- 'gt' => [/&gt;/, '&gt;', '>', />/],

- 'lt' => [/&lt;/, '&lt;', '<', /</],

- 'quot' => [/&quot;/, '&quot;', '"', /"/],

- "apos" => [/&apos;/, "&apos;", "'", /'/]

- }

- def initialize( source )

- self.stream = source

- end

- def stream=( source )

- if source.kind_of? String

- @source = Source.new(source)

- elsif source.kind_of? IO

- @source = IOSource.new(source)

- elsif source.kind_of? Source

- @source = source

- elsif defined? StringIO and source.kind_of? StringIO

- @source = IOSource.new(source)

- else

- raise "#{source.class} is not a valid input stream. It must be \n"+

- "either a String, IO, StringIO or Source."

- end

- @closed = nil

- @document_status = nil

- @tags = []

- @stack = []

- @entities = []

- end

- # Returns true if there are no more events

- def empty?

- #puts "@source.empty? = #{@source.empty?}"

- #puts "@stack.empty? = #{@stack.empty?}"

- end

- # Returns true if there are more events. Synonymous with !empty?

- def has_next?

- end

- # Push an event back on the head of the stream. This method

- # has (theoretically) infinite depth.

- def unshift token

- @stack.unshift(token)

- end

- # Peek at the +depth+ event in the stack. The first element on the stack

- # is at depth 0. If +depth+ is -1, will parse to the end of the input

- # stream and return the last event, which is always :end_document.

- # Be aware that this causes the stream to be parsed up to the +depth+

- # event, so you can effectively pre-parse the entire document (pull the

- # entire thing into memory) using this method.

- def peek depth=0

- raise %Q[Illegal argument "#{depth}"] if depth < -1

- temp = []

- if depth == -1

- temp.push(pull()) until empty?

- else

- while @stack.size+temp.size < depth+1

- temp.push(pull())

- end

- end

- @stack += temp if temp.size > 0

- @stack[depth]

- end

- # Returns the next event. This is a +PullEvent+ object.

- def pull

- if @closed

- x, @closed = @closed, nil

- return [ :end_element, x ]

- end

- return [ :end_document ] if empty?

- return @stack.shift if @stack.size > 0

- @source.read if @source.buffer.size<2

- if @document_status == nil

- @source.consume( /^\s*/um )

- word = @source.match( /(<[^>]*)>/um )

- word = word[1] unless word.nil?

- case word

- when COMMENT_START

- return [ :comment, @source.match( COMMENT_PATTERN, true )[1] ]

- when XMLDECL_START

- 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?

- @source.encoding = encoding

- 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

- md = @source.match( DOCTYPE_PATTERN, true )

- identity = md[1]

- close = md[2]

- identity =~ IDENTITY

- name = $1

- raise REXML::ParseException("DOCTYPE is missing a name") if name.nil?

- pub_sys = $2.nil? ? nil : $2.strip

- long_name = $3.nil? ? nil : $3.strip

- uri = $4.nil? ? nil : $4.strip

- args = [ :start_doctype, name, pub_sys, long_name, uri ]

- if close == ">"

- @document_status = :after_doctype

- @source.read if @source.buffer.size<2

- md = @source.match(/^\s*/um, true)

- @stack << [ :end_doctype ]

- else

- @document_status = :in_doctype

- end

- return args

- else

- @document_status = :after_doctype

- @source.read if @source.buffer.size<2

- md = @source.match(/\s*/um, true)

- end

- end

- if @document_status == :in_doctype

- md = @source.match(/\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 is [ :entity, name, PUBLIC, pubid, href ]

- 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

- end

- end

- return [ :attlistdecl, element, pairs, contents ]

- when NOTATIONDECL_START

- md = nil

- if @source.match( PUBLIC )

- md = @source.match( PUBLIC, true )

- elsif @source.match( SYSTEM )

- md = @source.match( SYSTEM, true )

- else

- raise REXML::ParseException.new( "error parsing notation: no matching pattern", @source )

- end

- return [ :notationdecl, md[1], md[2], md[3] ]

- when CDATA_END

- @document_status = :after_doctype

- @source.match( CDATA_END, true )

- return [ :end_doctype ]

- end

- end

- begin

- if @source.buffer[0] == ?<

- if @source.buffer[1] == ?/

- last_tag = @tags.pop

- #md = @source.match_to_consume( '>', CLOSE_MATCH)

- md = @source.match( CLOSE_MATCH, true )

- raise REXML::ParseException.new( "Missing end tag for "+

- return [ :end_element, last_tag ]

- elsif @source.buffer[1] == ?!

- md = @source.match(/\A(\s*[^>]*>)/um)

- #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 )

- return [ :comment, md[1] ] if md

- else

- md = @source.match( CDATA_PATTERN, 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)

- else

- # Get the next tag

- md = @source.match(TAG_MATCH, true)

- raise REXML::ParseException.new("malformed XML: missing tag start", @source) unless md

- attrs = []

- if md[2].size > 0

- attrs = md[2].scan( ATTRIBUTE_PATTERN )

- raise REXML::ParseException.new( "error parsing attributes: [#{attrs.join ', '}], excess = \"#$'\"", @source) if $' and $'.strip.size > 0

- end

-

- if md[4]

- @closed = md[1]

- else

- @tags.push( md[1] )

- end

- attributes = {}

- attrs.each { |a,b,c| attributes[a] = c }

- return [ :start_element, md[1], attributes ]

- end

- else

- md = @source.match( TEXT_PATTERN, true )

- #puts "EMPTY = #{empty?}"

- #puts "BUFFER = \"#{@source.buffer}\""

- # unnormalized = Text::unnormalize( md[1], self )

- # return PullEvent.new( :text, md[1], unnormalized )

- return [ :text, md[1] ]

- end

- rescue REXML::ParseException

- raise

- rescue Exception, NameError => error

- raise REXML::ParseException.new( "Exception parsing",

- @source, self, (error ? error : $!) )

- end

- return [ :dummy ]

- end

- 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

- end

- # Escapes all possible entities

- def normalize( input, entities=nil, entity_filter=nil )

- copy = input.clone

- # Doing it like this rather than in a loop improves the speed

- copy.gsub!( EREFERENCE, '&amp;' )

- entities.each do |key, value|

- copy.gsub!( value, "&#{key};" ) unless entity_filter and

- entity_filter.include?(entity)

- end if entities

- copy.gsub!( EREFERENCE, '&amp;' )

- DEFAULT_ENTITIES.each do |key, value|

- copy.gsub!( value[3], value[1] )

- end

- copy

- end

- # Unescapes all possible entities

- def unnormalize( string, entities=nil, filter=nil )

- rv = string.clone

- rv.gsub!( /\r\n?/, "\n" )

- matches = rv.scan( REFERENCE_RE )

- return rv if matches.size == 0

- rv.gsub!( /&#0*((?:\d+)|(?:x[a-fA-F0-9]+));/ ) {|m|

- m=$1

- m = "0#{m}" if m[0] == ?x

- [Integer(m)].pack('U*')

- }

- matches.collect!{|x|x[0]}.compact!

- 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 )

- end

- end

- end

- matches.each do |entity_reference|

- unless filter and filter.include?(entity_reference)

- er = DEFAULT_ENTITIES[entity_reference]

- rv.gsub!( er[0], er[2] ) if er

- end

- end

- rv.gsub!( /&amp;/, '&' )

- end

- rv

- end

- end

- end

- module Parsers

- # = Using the Pull Parser

- # <em>This API is experimental, and subject to change.</em>

- # parser = PullParser.new( "<a>text<b att='val'/>txet</a>" )

- # while parser.has_next?

- # res = parser.next

- # puts res[1]['att'] if res.start_tag? and res[0] == 'b'

- # end

- # See the PullEvent class for information on the content of the results.

- # The data is identical to the arguments passed for the various events to

- # the StreamListener API.

- #

- # Notice that:

- # parser = PullParser.new( "<a>BAD DOCUMENT" )

- # while parser.has_next?

- # res = parser.next

- # raise res[1] if res.error?

- # end

- #

- # Nat Price gave me some good ideas for the API.

- class PullParser

- include XMLTokens

-

- def initialize stream

- @entities = {}

- end

- def each

- while has_next?

- yield self.pull

- end

- end

-

- def peek depth=0

- PullEvent.new(@parser.peek(depth))

- end

-

- def has_next?

- @parser.has_next?

- def pull

- event = @parser.pull

- case event[0]

- when :entitydecl

- @entities[ event[1] ] =

- event[2] unless event[2] =~ /PUBLIC|SYSTEM/

- when :text

- unnormalized = @parser.unnormalize( event[1], @entities )

- event << unnormalized

- end

- PullEvent.new( event )

- end

-

- def unshift token

- @parser.unshift token

- def entity reference

- @parser.entity( reference )

- def empty?

- @parser.empty?

-

- end

-

- # A parsing event. The contents of the event are accessed as an +Array?,

- # and the type is given either by the ...? methods, or by accessing the

- # +type+ accessor. The contents of this object vary from event to event,

- # but are identical to the arguments passed to +StreamListener+s for each

- # event.

- class PullEvent

- # The type of this event. Will be one of :tag_start, :tag_end, :text,

- # :processing_instruction, :comment, :doctype, :attlistdecl, :entitydecl,

- # :notationdecl, :entity, :cdata, :xmldecl, or :error.

- def initialize(arg)

- @contents = arg

- end

- end

-

- def event_type

- @contents[0]

- end

-

- # Content: [ String tag_name, Hash attributes ]

- def start_element?

- @contents[0] == :start_element

- end

-

- # Content: [ String tag_name ]

- def end_element?

- @contents[0] == :end_element

- end

-

- # Content: [ String raw_text, String unnormalized_text ]

- def text?

- @contents[0] == :text

- end

-

- # Content: [ String text ]

- def instruction?

- @contents[0] == :processing_instruction

- end

-

- # Content: [ String text ]

- def comment?

- @contents[0] == :comment

- end

-

- # Content: [ String name, String pub_sys, String long_name, String uri ]

- def doctype?

- @contents[0] == :start_doctype

- end

-

- # Content: [ String text ]

- def attlistdecl?

- @contents[0] == :attlistdecl

- end

-

- # Content: [ String text ]

- def elementdecl?

- @contents[0] == :elementdecl

- end

-

- # Due to the wonders of DTDs, an entity declaration can be just about

- # anything. There's no way to normalize it; you'll have to interpret the

- # content yourself. However, the following is true:

- #

- # * If the entity declaration is an internal entity:

- # [ String name, String value ]

- # Content: [ String text ]

- def entitydecl?

- @contents[0] == :entitydecl

- end

-

- # Content: [ String text ]

- def notationdecl?

- @contents[0] == :notationdecl

- end

-

- # Content: [ String text ]

- def entity?

- @contents[0] == :entity

- end

-

- # Content: [ String text ]

- def cdata?

- @contents[0] == :cdata

- end

-

- # Content: [ String version, String encoding, String standalone ]

- def xmldecl?

- @contents[0] == :xmldecl

- end

-

- def error?

- @contents[0] == :error

- end

-

- def inspect

- end

- end

- end

- module Parsers

- class StreamParser

- def initialize source, listener

- @listener = listener

- @parser = BaseParser.new( source )

- end

-

-

- def parse

- # entity string

- while true

- event = @parser.pull

- case event[0]

- when :end_document

- return

- when :start_element

- 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] )

- when :text

- normalized = @parser.unnormalize( event[1] )

- @listener.text( normalized )

- when :processing_instruction

- @listener.instruction( *event[1,2] )

- when :comment, :attlistdecl, :notationdecl, :elementdecl,

- :entitydecl, :cdata, :xmldecl, :attlistdecl

- @listener.send( event[0].to_s, *event[1..-1] )

- end

- end

- end

- end

- end

- Text.new( event[1], @build_context.whitespace, nil, true )

- event[1].strip.size==0 and

- @build_context.ignore_whitespace_nodes

-# Version:: 3.1.3

-# Date:: +2005/139

- Copyright = "Copyright © 2001-2005 Sean Russell <[email protected]>"

- Date = "+2005/139"

- Version = "3.1.3"

- if arg.kind_of? String

- source = Source.new(arg)

- elsif arg.kind_of? IO

- source = IOSource.new(arg)

- end

- source

- # Text.new( "<&", false, nil, true ) #-> IllegalArgumentException

- # t.string #-> "< & sean russell"

- # t.string #-> "< & sean russell"

- # u.string #-> "sean russell"

- copy = input.clone

- attr_reader :done?

- # NEEDS DOCUMENTATION

- class XMLDecl < Child

- include Encoding

- DEFAULT_VERSION = "1.0";

- DEFAULT_ENCODING = "UTF-8";

- DEFAULT_STANDALONE = "no";

- START = '<\?xml';

- STOP = '\?>';

- attr_accessor :version, :standalone

- def initialize(version=DEFAULT_VERSION, encoding=nil, standalone=nil)

- if version.kind_of? XMLDecl

- super()

- @version = version.version

- self.encoding = version.encoding

- @standalone = version.standalone

- else

- super()

- @version = version

- self.encoding = encoding

- @standalone = standalone

- end

- @version = DEFAULT_VERSION if @version.nil?

- end

-

- def clone

- XMLDecl.new(self)

- end

-

- def write writer, indent_level=-1, transitive=false, ie_hack=false

- indent( writer, indent_level )

- writer << START.sub(/\\/u, '')

- writer << STOP.sub(/\\/u, '')

- end

-

- def ==( other )

- other.kind_of?(XMLDecl) and

- other.version == @version and

- other.encoding == self.encoding and

- other.standalone == @standalone

- end

-

- def xmldecl version, encoding, standalone

- @version = version

- self.encoding = encoding

- @standalone = standalone

- end

-

- def node_type

- :xmldecl

- end

-

- alias :stand_alone? :standalone

- private

- def content(enc)

- rv = "version='#@version'"

- rv << " encoding='#{enc}'" if @writeencoding || enc !~ /utf-8/i

- rv << " standalone='#@standalone'" if @standalone

- rv

- end

- end

- # Wrapper class. Use this class to access the XPath functions.

- class XPath

- include Functions

- EMPTY_HASH = {}

- # Finds and returns the first node that matches the supplied xpath.

- # element::

- # The context element

- # path::

- # The xpath to search for. If not supplied or nil, returns the first

- # node matching '*'.

- # namespaces::

- # If supplied, a Hash which defines a namespace mapping.

- #

- # XPath.first( node )

- # XPath.first( doc, "//b"} )

- # XPath.first( node, "a/x:b", { "x"=>"http://doofus" } )

-=begin

- parser = XPathParser.new

- parser.namespaces = namespaces

- parser.variables = variables

- path = "*" unless path

- parser.first( path, element );

-=end

-#=begin

- raise "The namespaces argument, if supplied, must be a hash object." unless namespaces.kind_of? Hash

- raise "The variables argument, if supplied, must be a hash object." unless variables.kind_of? Hash

- parser = XPathParser.new

- parser.namespaces = namespaces

- parser.variables = variables

- path = "*" unless path

- element = [element] unless element.kind_of? Array

- parser.parse(path, element).flatten[0]

-#=end

- end

- # Itterates over nodes that match the given path, calling the supplied

- # block with the match.

- # element::

- # The context element

- # path::

- # The xpath to search for. If not supplied or nil, defaults to '*'

- # namespaces::

- # If supplied, a Hash which defines a namespace mapping

- #

- # XPath.each( node ) { |el| ... }

- # XPath.each( node, '/*[@attr='v']' ) { |el| ... }

- # XPath.each( node, 'ancestor::x' ) { |el| ... }

- def XPath::each element, path=nil, namespaces={}, variables={}, &block

- parser = XPathParser.new

- parser.namespaces = namespaces

- parser.variables = variables

- path = "*" unless path

- element = [element] unless element.kind_of? Array

- parser.parse(path, element).each( &block )

- end

- # Returns an array of nodes matching a given XPath.

- def XPath::match element, path=nil, namespaces={}, variables={}

- parser = XPathParser.new

- parser.namespaces = namespaces

- parser.variables = variables

- path = "*" unless path

- element = [element] unless element.kind_of? Array

- parser.parse(path,element)

- end

- end

-

- #while ( path_stack.size > 0 and nodeset.size > 0 )

- # #puts "MATCH: #{path_stack.inspect} '#{nodeset.collect{|n|n.class}.inspect}'"

- # nodeset = expr( path_stack, nodeset )

- # #puts "NODESET: #{nodeset.inspect}"

- # #puts "PATH_STACK: #{path_stack.inspect}"

- #end

- #nodeset

- ns = @namespaces[prefix]

- ns = ns ? ns : ''

- nodeset = preceding_siblings

- left = expr( path_stack.shift, nodeset, context )

- right = expr( path_stack.shift, nodeset, context )

- #puts "RS = #{rs.collect{|n|n.to_s}.inspect}"