unless @children.empty?

next_indent = indent + 1

output << ' ['

@children.each { |child|

output << "\n"

f.write( child, output )

raise "First argument must be either an element name, or an Element object" if element.nil?

el = @elements.add(element)

attrs.each do |key, value|

end if attrs.kind_of? Hash

el

end

def attribute( name, namespace=nil )

prefix = nil

prefix = nil if prefix == 'xmlns'

attributes.get_attribute( "#{prefix ? prefix + ':' : ''}#{name}" )

end

# A private helper method

def each_with_something( test, max=0, name=nil )

num = 0

@elements.each( name ){ |child|

yield child if test.call(child) and num += 1

return if max>0 and num == max

raise "index (#{index}) must be >= 1" if index < 1

name = literalize(name) if name

num = 0

@element.find { |child|

child.kind_of? Element and

(name.nil? ? true : child.has_name?( name )) and

def get_attribute_ns(namespace, name)

each_attribute() { |attribute|

if name == attribute.name &&

return attribute

end

}

def check_encoding str

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

str[0,2] = ""

return UTF_16

str[0,2] = ""

return UNILE

end

return $3.upcase if $3

return UTF_8

end

if @parent

matches.each do |entity_reference|

entity_value = @parent.entity( entity_reference[0] )

end

end

return rv

@level = 0

@ie_hack = ie_hack

@width = 80

end

protected

end

}

end

# UNTESTED

@document_status = :after_doctype

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

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

end

end

if @document_status == :in_doctype

procs = get_procs( :end_prefix_mapping, event[1] )

listeners = get_listeners( :end_prefix_mapping, event[1] )

if procs or listeners

# notify observers of namespaces

end

end

when :text

#normalized = @parser.normalize( event[1] )

#handle( :characters, normalized )

copy = event[1].clone

copy.gsub!( Text::NUMERICENTITY ) {|m|

m=$1

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

return

when :start_element

tag_stack.push(event[1])

when :end_element

tag_stack.pop

@build_context = @build_context.parent

predicates << expr[1..-2] if expr

end

#puts "PREDICATES = #{predicates.inspect}"

preds = []

parsed << :predicate

parsed << preds

}

#puts "PREDICATES = #{predicates.inspect}"

path

@to_utf = true

else

@to_utf = false

end

end

str = @source.read( 2 )

if encoding

self.encoding = encoding

@line_break = "\000>"

@line_break = ">\000"

str += @source.read(1)

@line_break = ">"

else

@line_break = ">"

str = @source.readline(@line_break)

str = decode(str) if @to_utf and str

@buffer << str

rescue Exception, NameError

@source = nil

end

# Enumerable objects.

def initialize(*enums)

@gens = enums

end

# Returns the number of enumerated Enumerable objects, i.e. the size

# Enumerates rows of the Enumerable objects.

def each

}

self

end

# Unescapes all possible entities

def Text::unnormalize( string, doctype=nil, filter=nil, illegal=nil )

end

else

end

end

end

end

sattr = [:start_attribute, nil]

eattr = [:end_attribute]

text = [:text, nil]

#puts "Looking for #{sattr.inspect}"

m = @current.next( sattr )

#puts "Got #{m.inspect}"

@current = m

else

#puts "Didn't get end"

#puts "Looking for #{text.inspect}"

m = m.next( text )

#puts "Got #{m.inspect}"

when :child

new_nodeset = []

nt = nil

nt = node.node_type

new_nodeset += node.children if nt == :element or nt == :document

end

when :ancestor

new_nodeset = []

while node.parent

node = node.parent

new_nodeset << node unless new_nodeset.include? node

when :ancestor_or_self

new_nodeset = []

if node.node_type == :element

new_nodeset << node

while ( node.parent )

when :descendant

results = []

nt = nil

nt = node.node_type

results += expr( path_stack.dclone.unshift( :descendant_or_self ),

node.children ) if nt == :element or nt == :document

when :preceding

new_nodeset = []

new_nodeset += preceding( node )

end

#puts "NEW NODESET => #{new_nodeset.inspect}"

when :following

new_nodeset = []

new_nodeset += following( node )

end

nodeset = new_nodeset

#puts "In :namespace"

new_nodeset = []

prefix = path_stack.shift

if (node.node_type == :element or node.node_type == :attribute)

if @namespaces

namespaces = @namespaces