Class: REXML::Parsers::TreeParser (Ruby 2.3.7)
Description: Class : REXML::Parsers::TreeParser - Ruby 2.3.7

- Home
- Core 2.3.7
- Std-lib 2.3.7
- Downloads

Support for the Ruby 2.3 series has ended. See here for reference.

### Home Classes Methods

### In Files

- rexml/parsers/treeparser.rb

### Parent

Object

### Methods

- ::new
- #add_listener
- #parse

### Class/Module Index

Quicksearch

- Array
- Fixnum
- Float
- Object
- REXML
- REXML::AttlistDecl
- REXML::Attribute
- REXML::Attributes
- REXML::CData
- REXML::Child
- REXML::Comment
- REXML::DTD
- REXML::DTD::AttlistDecl
- REXML::DTD::ElementDecl
- REXML::DTD::EntityDecl
- REXML::DTD::NotationDecl
- REXML::DTD::Parser
- REXML::Declaration
- REXML::DocType
- REXML::Document
- REXML::Element
- REXML::ElementDecl
- REXML::Elements
- REXML::Encoding
- REXML::Entity
- REXML::EntityConst
- REXML::ExternalEntity
- REXML::Formatters
- REXML::Formatters::Default
- REXML::Formatters::Pretty
- REXML::Formatters::Transitive
- REXML::Functions
- REXML::IOSource
- REXML::Instruction
- REXML::Light
- REXML::Light::Node
- REXML::Namespace
- REXML::Node
- REXML::NotationDecl
- REXML::Output
- REXML::Parent
- REXML::ParseException
- REXML::Parsers
- REXML::Parsers::BaseParser
- REXML::Parsers::LightParser
- REXML::Parsers::PullEvent
- REXML::Parsers::PullParser
- REXML::Parsers::SAX2Parser
- REXML::Parsers::StreamParser
- REXML::Parsers::TreeParser
- REXML::Parsers::UltraLightParser
- REXML::Parsers::XPathParser
- REXML::QuickPath
- REXML::SAX2Listener
- REXML::Security
- REXML::Source
- REXML::SourceFactory
- REXML::StreamListener
- REXML::SyncEnumerator
- REXML::Text
- REXML::UndefinedNamespaceException
- REXML::Validation
- REXML::Validation::Choice
- REXML::Validation::Event
- REXML::Validation::Interleave
- REXML::Validation::OneOrMore
- REXML::Validation::Optional
- REXML::Validation::Ref
- REXML::Validation::RelaxNG
- REXML::Validation::Sequence
- REXML::Validation::State
- REXML::Validation::ValidationException
- REXML::Validation::Validator
- REXML::Validation::ZeroOrMore
- REXML::XMLDecl
- REXML::XMLTokens
- REXML::XPath
- REXML::XPathParser
- Symbol

No matching classes.

# REXML::Parsers::TreeParser

### Public Class Methods

new( source, build_context = Document.new ) click to toggle source

                   # File rexml/parsers/treeparser.rb, line 7
    def initialize( source, build_context = Document.new )
      @build_context = build_context
      @parser = Parsers::BaseParser.new( source )
    end

### Public Instance Methods

add_listener( listener ) click to toggle source

                   # File rexml/parsers/treeparser.rb, line 12
    def add_listener( listener )
      @parser.add_listener( listener )
    end

parse() click to toggle source

                   # File rexml/parsers/treeparser.rb, line 16
    def parse
      tag_stack = []
      in_doctype = false
      entities = nil
      begin
        while true
          event = @parser.pull
          #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
            end
          when :comment
            c = Comment.new( event[1] )
            @build_context.add( c )
          when :cdata
            c = CData.new( event[1] )
            @build_context.add( c )
          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 )
          when :externalentity
            n = ExternalEntity.new( event[1] )
            @build_context.add( n )
          when :elementdecl
            n = ElementDecl.new( event[1] )
            @build_context.add(n)
          when :entitydecl
            entities[ event[1] ] = event[2] unless event[2] =~ /PUBLIC|SYSTEM/
            @build_context.add(Entity.new(event))
          when :notationdecl
            n = NotationDecl.new( *event[1..-1] )
            @build_context.add( n )
          when :xmldecl
            x = XMLDecl.new( event[1], event[2], event[3] )
            @build_context.add( x )
          end
        end
      rescue REXML::Validation::ValidationException
        raise
      rescue REXML::ParseException
        raise
      rescue
        raise ParseException.new( $!.message, @parser.source, @parser, $! )
      end
    end