ActiveRuby 2.3.4 Beta Documentation

Index of Classes & Methods in rexml: Ruby Standard Library Documentation (Ruby 2.3.4)

Ruby 2.3.4

frozen_string_literal: false REXML is an XML toolkit for Ruby, in Ruby.

REXML is a pure Ruby, XML 1.0 conforming, non-validating toolkit with an intuitive API. REXML passes 100% of the non-validating Oasis tests, and provides tree, stream, SAX2, pull, and lightweight APIs. REXML also includes a full XPath 1.0 implementation. Since Ruby 1.8, REXML is included in the standard Ruby distribution.

Main page: www.germane-software.com/software/rexml
Author: Sean Russell <serATgermaneHYPHENsoftwareDOTcom>
Date: 2008/019
Version: 3.1.7.3

This API documentation can be downloaded from the REXML home page, or can be accessed online

A tutorial is available in the REXML distribution in docs/tutorial.html, or can be accessed online

Classes

CREXML::AttlistDecl

CREXML::Attribute

CREXML::Attributes

CREXML::Comment

CREXML::DTD::AttlistDecl

CREXML::DTD::ElementDecl

CREXML::DTD::EntityDecl

CREXML::DTD::NotationDecl

CREXML::DTD::Parser

CREXML::Declaration

CREXML::DocType

CREXML::Document

CREXML::Element

CREXML::ElementDecl

CREXML::Elements

MREXML::Encoding

MREXML::EntityConst

CREXML::ExternalEntity

MREXML::Formatters

CREXML::Formatters::Default

CREXML::Formatters::Pretty

CREXML::Formatters::Transitive

MREXML::Functions

CREXML::IOSource

CREXML::Instruction

CREXML::Light::Node

MREXML::Namespace

CREXML::NotationDecl

CREXML::ParseException

MREXML::Parsers

CREXML::Parsers::BaseParser

CREXML::Parsers::LightParser

CREXML::Parsers::PullEvent

CREXML::Parsers::PullParser

CREXML::Parsers::SAX2Parser

CREXML::Parsers::StreamParser

CREXML::Parsers::TreeParser

CREXML::Parsers::UltraLightParser

CREXML::Parsers::XPathParser

CREXML::QuickPath

MREXML::SAX2Listener

MREXML::Security

CREXML::SourceFactory

MREXML::StreamListener

CREXML::SyncEnumerator

CREXML::UndefinedNamespaceException

MREXML::Validation

CREXML::Validation::Choice

CREXML::Validation::Event

CREXML::Validation::Interleave

CREXML::Validation::OneOrMore

CREXML::Validation::Optional

CREXML::Validation::Ref

CREXML::Validation::RelaxNG

CREXML::Validation::Sequence

CREXML::Validation::State

CREXML::Validation::ValidationException

MREXML::Validation::Validator

CREXML::Validation::ZeroOrMore

CREXML::XMLDecl

MREXML::XMLTokens

CREXML::XPathParser

Methods

::attribute (REXML::QuickPath)

::axe (REXML::QuickPath)

::boolean (REXML::Functions)

::ceiling (REXML::Functions)

::check (REXML::Text)

::compare_language (REXML::Functions)

::concat (REXML::Functions)

::contains (REXML::Functions)

::context= (REXML::Functions)

::count (REXML::Functions)

::create_from (REXML::SourceFactory)

::default (REXML::XMLDecl)

::each (REXML::QuickPath)

::each (REXML::XPath)

::entity_expansion_limit (REXML::Document)

::entity_expansion_limit (REXML::Security)

::entity_expansion_limit= (REXML::Document)

::entity_expansion_limit= (REXML::Security)

::entity_expansion_text_limit (REXML::Document)

::entity_expansion_text_limit (REXML::Security)

::entity_expansion_text_limit= (REXML::Document)

::entity_expansion_text_limit= (REXML::Security)

::false (REXML::Functions)

::filter (REXML::QuickPath)

::first (REXML::QuickPath)

::first (REXML::XPath)

::floor (REXML::Functions)

::function (REXML::QuickPath)

::get_namespace (REXML::Functions)

::id (REXML::Functions)

::lang (REXML::Functions)

::last (REXML::Functions)

::local_name (REXML::Functions)

::match (REXML::QuickPath)

::match (REXML::XPath)

::matches? (REXML::Entity)

::method_missing (REXML::Functions)

::method_missing (REXML::QuickPath)

::name (REXML::Functions)

::name (REXML::QuickPath)

::namespace_context (REXML::Functions)

::namespace_context= (REXML::Functions)

::namespace_uri (REXML::Functions)

::new (REXML::AttlistDecl)

::new (REXML::Attribute)

::new (REXML::Attributes)

::new (REXML::CData)

::new (REXML::Child)

::new (REXML::Comment)

::new (REXML::DTD::ElementDecl)

::new (REXML::DTD::EntityDecl)

::new (REXML::DTD::NotationDecl)

::new (REXML::Declaration)

::new (REXML::DocType)

::new (REXML::Document)

::new (REXML::Element)

::new (REXML::ElementDecl)

::new (REXML::Elements)

::new (REXML::Entity)

::new (REXML::ExternalEntity)

::new (REXML::Formatters::Default)

::new (REXML::Formatters::Pretty)

::new (REXML::Formatters::Transitive)

::new (REXML::IOSource)

::new (REXML::Instruction)

::new (REXML::Light::Node)

::new (REXML::NotationDecl)

::new (REXML::Output)

::new (REXML::Parent)

::new (REXML::ParseException)

::new (REXML::Parsers::BaseParser)

::new (REXML::Parsers::LightParser)

::new (REXML::Parsers::PullEvent)

::new (REXML::Parsers::PullParser)

::new (REXML::Parsers::SAX2Parser)

::new (REXML::Parsers::StreamParser)

::new (REXML::Parsers::TreeParser)

::new (REXML::Parsers::UltraLightParser)

::new (REXML::Source)

::new (REXML::SyncEnumerator)

::new (REXML::Text)

::new (REXML::UndefinedNamespaceException)

::new (REXML::Validation::Choice)

::new (REXML::Validation::Event)

::new (REXML::Validation::Interleave)

::new (REXML::Validation::OneOrMore)

::new (REXML::Validation::Ref)

::new (REXML::Validation::RelaxNG)

::new (REXML::Validation::State)

::new (REXML::Validation::ValidationException)

::new (REXML::XMLDecl)

::new (REXML::XPathParser)

::normalize_space (REXML::Functions)

::not (REXML::Functions)

::number (REXML::Functions)

::parse (REXML::DTD::Parser)

::parse_args (REXML::QuickPath)

::parse_helper (REXML::DTD::Parser)

::parse_source (REXML::DTD::EntityDecl)

::parse_source (REXML::DTD::NotationDecl)

::parse_stream (REXML::Document)

::position (REXML::Functions)

::predicate (REXML::QuickPath)

::processing_instruction (REXML::Functions)

::round (REXML::Functions)

::starts_with (REXML::Functions)

::string (REXML::Functions)

::string_length (REXML::Functions)

::string_value (REXML::Functions)

::substring (REXML::Functions)

::substring_after (REXML::Functions)

::substring_before (REXML::Functions)

::sum (REXML::Functions)

::text (REXML::Functions)

::translate (REXML::Functions)

::true (REXML::Functions)

::variables (REXML::Functions)

::variables= (REXML::Functions)

#<< (REXML::Attributes)

#<< (REXML::Document)

#<< (REXML::Elements)

#<< (REXML::Light::Node)

#<< (REXML::Output)

#<< (REXML::Parent)

#<< (REXML::Text)

#<< (REXML::Validation::Choice)

#<< (REXML::Validation::State)

#<=> (REXML::Comment)

#<=> (REXML::Text)

#== (REXML::Attribute)

#== (REXML::Comment)

#== (REXML::Instruction)

#== (REXML::Validation::Event)

#== (REXML::XMLDecl)

#=~ (REXML::Light::Node)

#[] (REXML::AttlistDecl)

#[] (REXML::Attributes)

#[] (REXML::Elements)

#[] (REXML::Light::Node)

#[] (REXML::Parent)

#[] (REXML::Parsers::PullEvent)

#[]= (REXML::Attributes)

#[]= (REXML::Elements)

#[]= (REXML::Light::Node)

#[]= (REXML::Parent)

#[]= (REXML::XPathParser)

#abbreviate (REXML::Parsers::XPathParser)

#add (REXML::Attributes)

#add (REXML::DocType)

#add (REXML::Document)

#add (REXML::Elements)

#add (REXML::Parent)

#add_attribute (REXML::Element)

#add_attributes (REXML::Element)

#add_element (REXML::Document)

#add_element (REXML::Element)

#add_event_to_arry (REXML::Validation::Choice)

#add_event_to_arry (REXML::Validation::State)

#add_listener (REXML::Parsers::BaseParser)

#add_listener (REXML::Parsers::LightParser)

#add_listener (REXML::Parsers::PullParser)

#add_listener (REXML::Parsers::SAX2Parser)

#add_listener (REXML::Parsers::StreamParser)

#add_listener (REXML::Parsers::TreeParser)

#add_listener (REXML::Parsers::UltraLightParser)

#add_namespace (REXML::Element)

#add_text (REXML::Element)

#attlistdecl (REXML::SAX2Listener)

#attlistdecl (REXML::StreamListener)

#attlistdecl? (REXML::Parsers::PullEvent)

#attribute (REXML::Element)

#attribute_of (REXML::DocType)

#attributes_of (REXML::DocType)

#bytes (REXML::Child)

#cdata (REXML::SAX2Listener)

#cdata (REXML::StreamListener)

#cdata? (REXML::Parsers::PullEvent)

#cdatas (REXML::Element)

#characters (REXML::SAX2Listener)

#children (REXML::Light::Node)

#children (REXML::Parent)

#clone (REXML::Attribute)

#clone (REXML::CData)

#clone (REXML::Comment)

#clone (REXML::DocType)

#clone (REXML::Document)

#clone (REXML::Element)

#clone (REXML::Instruction)

#clone (REXML::Text)

#clone (REXML::XMLDecl)

#collect (REXML::Elements)

#comment (REXML::SAX2Listener)

#comment (REXML::StreamListener)

#comment? (REXML::Parsers::PullEvent)

#comments (REXML::Element)

#consume (REXML::IOSource)

#consume (REXML::Source)

#context (REXML::DocType)

#context (REXML::ParseException)

#current_line (REXML::IOSource)

#current_line (REXML::Source)

#dclone (Array)

#dclone (Fixnum)

#dclone (Float)

#dclone (Object)

#dclone (Symbol)

#deafen (REXML::Parsers::SAX2Parser)

#decode (REXML::Encoding)

#deep_clone (REXML::Parent)

#delete (REXML::Attributes)

#delete (REXML::Elements)

#delete (REXML::Parent)

#delete_all (REXML::Attributes)

#delete_all (REXML::Elements)

#delete_at (REXML::Parent)

#delete_attribute (REXML::Element)

#delete_element (REXML::Element)

#delete_if (REXML::Parent)

#delete_namespace (REXML::Element)

#doctype (REXML::Attribute)

#doctype (REXML::Document)

#doctype (REXML::SAX2Listener)

#doctype (REXML::StreamListener)

#doctype (REXML::Text)

#doctype? (REXML::Parsers::PullEvent)

#doctype_end (REXML::StreamListener)

#document (REXML::Child)

#document (REXML::Document)

#document (REXML::Element)

#done? (REXML::Validation::Event)

#dowrite (REXML::XMLDecl)

#dump (REXML::Validation::Validator)

#each (REXML::AttlistDecl)

#each (REXML::Attributes)

#each (REXML::Elements)

#each (REXML::Light::Node)

#each (REXML::Parent)

#each (REXML::Parsers::PullParser)

#each (REXML::SyncEnumerator)

#each_attribute (REXML::Attributes)

#each_child (REXML::Parent)

#each_element (REXML::Element)

#each_element_with_attribute (REXML::Element)

#each_element_with_text (REXML::Element)

#each_index (REXML::Parent)

#each_recursive (REXML::Node)

#element= (REXML::Attribute)

#elementdecl (REXML::SAX2Listener)

#elementdecl (REXML::StreamListener)

#elementdecl? (REXML::Parsers::PullEvent)

#empty? (REXML::Elements)

#empty? (REXML::IOSource)

#empty? (REXML::Parsers::BaseParser)

#empty? (REXML::Source)

#empty? (REXML::Text)

#encode (REXML::Encoding)

#encoding (REXML::Document)

#encoding= (REXML::Encoding)

#encoding= (REXML::Source)

#encoding= (REXML::XMLDecl)

#end_document (REXML::SAX2Listener)

#end_element (REXML::SAX2Listener)

#end_element? (REXML::Parsers::PullEvent)

#end_prefix_mapping (REXML::SAX2Listener)

#entity (REXML::DocType)

#entity (REXML::Parsers::BaseParser)

#entity (REXML::StreamListener)

#entity? (REXML::Parsers::PullEvent)

#entitydecl (REXML::SAX2Listener)

#entitydecl (REXML::StreamListener)

#entitydecl? (REXML::Parsers::PullEvent)

#error? (REXML::Parsers::PullEvent)

#event_type (REXML::Parsers::PullEvent)

#expand (REXML::Parsers::XPathParser)

#expand_ref_in (REXML::Validation::State)

#expanded_name (REXML::Document)

#expected (REXML::Validation::Choice)

#expected (REXML::Validation::Interleave)

#expected (REXML::Validation::OneOrMore)

#expected (REXML::Validation::Optional)

#expected (REXML::Validation::State)

#expected (REXML::Validation::ZeroOrMore)

#find_first_recursive (REXML::Node)

#first (REXML::XPathParser)

#fully_expanded_name (REXML::Namespace)

#generate_event (REXML::Validation::State)

#get_attribute (REXML::Attributes)

#get_attribute_ns (REXML::Attributes)

#get_elements (REXML::Element)

#get_first (REXML::XPathParser)

#get_text (REXML::Element)

#has_attributes? (REXML::Element)

#has_elements? (REXML::Element)

#has_name? (REXML::Light::Node)

#has_name? (REXML::Namespace)

#has_next? (REXML::Parsers::BaseParser)

#has_text? (REXML::Element)

#hash (REXML::Attribute)

#ignore_whitespace_nodes (REXML::Element)

#include? (REXML::AttlistDecl)

#indent (REXML::Node)

#indent_text (REXML::Text)

#index (REXML::Elements)

#index (REXML::Parent)

#index_in_parent (REXML::Node)

#inject (REXML::Elements)

#insert_after (REXML::Parent)

#insert_before (REXML::Parent)

#inspect (REXML::Attribute)

#inspect (REXML::Element)

#inspect (REXML::Instruction)

#inspect (REXML::Parsers::PullEvent)

#inspect (REXML::Text)

#inspect (REXML::Validation::Choice)

#inspect (REXML::Validation::Event)

#inspect (REXML::Validation::Interleave)

#inspect (REXML::Validation::Ref)

#inspect (REXML::Validation::State)

#inspect (REXML::XMLDecl)

#instruction (REXML::StreamListener)

#instruction? (REXML::Parsers::PullEvent)

#instructions (REXML::Element)

#length (REXML::Attributes)

#length (REXML::Parent)

#length (REXML::SyncEnumerator)

#line (REXML::ParseException)

#listen (REXML::Parsers::SAX2Parser)

#local_name (REXML::Light::Node)

#local_name= (REXML::Light::Node)

#match (REXML::IOSource)

#match (REXML::Source)

#match (REXML::XPathParser)

#match_to (REXML::Source)

#match_to_consume (REXML::Source)

#matches? (REXML::Validation::Choice)

#matches? (REXML::Validation::Event)

#matches? (REXML::Validation::Interleave)

#matches? (REXML::Validation::OneOrMore)

#matches? (REXML::Validation::Optional)

#matches? (REXML::Validation::Sequence)

#name (REXML::Document)

#name (REXML::Light::Node)

#name (REXML::NotationDecl)

#name= (REXML::Light::Node)

#name= (REXML::Namespace)

#namespace (REXML::Attribute)

#namespace (REXML::Element)

#namespace (REXML::Light::Node)

#namespace= (REXML::Light::Node)

#namespaces (REXML::Attributes)

#namespaces (REXML::Element)

#namespaces= (REXML::Parsers::XPathParser)

#namespaces= (REXML::XPathParser)

#next (REXML::Validation::Choice)

#next (REXML::Validation::Interleave)

#next (REXML::Validation::OneOrMore)

#next (REXML::Validation::Optional)

#next (REXML::Validation::State)

#next (REXML::Validation::ZeroOrMore)

#next_current (REXML::Validation::Interleave)

#next_element (REXML::Element)

#next_sibling= (REXML::Child)

#next_sibling_node (REXML::Node)

#node_type (REXML::AttlistDecl)

#node_type (REXML::Attribute)

#node_type (REXML::Comment)

#node_type (REXML::DocType)

#node_type (REXML::Document)

#node_type (REXML::Element)

#node_type (REXML::Instruction)

#node_type (REXML::Light::Node)

#node_type (REXML::Text)

#node_type (REXML::XMLDecl)

#normalize (REXML::Parsers::BaseParser)

#normalized (REXML::Entity)

#notation (REXML::DocType)

#notationdecl (REXML::SAX2Listener)

#notationdecl (REXML::StreamListener)

#notationdecl? (REXML::Parsers::PullEvent)

#notations (REXML::DocType)

#nowrite (REXML::XMLDecl)

#old_enc= (REXML::XMLDecl)

#parent (REXML::Light::Node)

#parent= (REXML::Child)

#parent= (REXML::Light::Node)

#parent= (REXML::Text)

#parent? (REXML::Node)

#parent? (REXML::Parent)

#parse (REXML::Parsers::LightParser)

#parse (REXML::Parsers::SAX2Parser)

#parse (REXML::Parsers::StreamParser)

#parse (REXML::Parsers::TreeParser)

#parse (REXML::Parsers::UltraLightParser)

#parse (REXML::Parsers::XPathParser)

#parse (REXML::XPathParser)

#peek (REXML::Parsers::BaseParser)

#peek (REXML::Parsers::PullParser)

#position (REXML::IOSource)

#position (REXML::ParseException)

#position (REXML::Parsers::BaseParser)

#position (REXML::Source)

#predicate (REXML::Parsers::XPathParser)

#predicate (REXML::XPathParser)

#predicate_to_string (REXML::Parsers::XPathParser)

#prefix (REXML::Attribute)

#prefix (REXML::Light::Node)

#prefixes (REXML::Attributes)

#prefixes (REXML::Element)

#previous= (REXML::Validation::State)

#previous_element (REXML::Element)

#previous_sibling= (REXML::Child)

#previous_sibling_node (REXML::Node)

#processing_instruction (REXML::SAX2Listener)

#progress (REXML::SAX2Listener)

#public (REXML::DocType)

#pull (REXML::Parsers::BaseParser)

#pull (REXML::Parsers::PullParser)

#push (REXML::Parent)

#raw (REXML::Element)

#read (REXML::IOSource)

#read (REXML::Source)

#receive (REXML::Validation::RelaxNG)

#record_entity_expansion (REXML::Document)

#remove (REXML::Attribute)

#remove (REXML::Child)

#replace_child (REXML::Parent)

#replace_with (REXML::Child)

#reset (REXML::Validation::Choice)

#reset (REXML::Validation::Interleave)

#reset (REXML::Validation::OneOrMore)

#reset (REXML::Validation::State)

#reset (REXML::Validation::Validator)

#rewind (REXML::Parsers::LightParser)

#rewind (REXML::Parsers::UltraLightParser)

#root (REXML::Document)

#root (REXML::Element)

#root (REXML::Light::Node)

#root_node (REXML::Element)

#scan (REXML::IOSource)

#scan (REXML::Source)

#single? (REXML::Validation::Event)

#size (REXML::Attributes)

#size (REXML::Elements)

#size (REXML::Light::Node)

#size (REXML::Parent)

#size (REXML::SyncEnumerator)

#source (REXML::Parsers::SAX2Parser)

#stand_alone? (REXML::Document)

#start_document (REXML::SAX2Listener)

#start_element (REXML::SAX2Listener)

#start_element? (REXML::Parsers::PullEvent)

#start_prefix_mapping (REXML::SAX2Listener)

#stream= (REXML::Parsers::BaseParser)

#system (REXML::DocType)

#tag_end (REXML::StreamListener)

#tag_start (REXML::StreamListener)

#text (REXML::Element)

#text (REXML::StreamListener)

#text= (REXML::Element)

#text= (REXML::Light::Node)

#text? (REXML::Parsers::PullEvent)

#texts (REXML::Element)

#to_a (REXML::Attributes)

#to_a (REXML::Elements)

#to_a (REXML::Parent)

#to_s (REXML::Attribute)

#to_s (REXML::CData)

#to_s (REXML::DTD::EntityDecl)

#to_s (REXML::DTD::NotationDecl)

#to_s (REXML::Declaration)

#to_s (REXML::Entity)

#to_s (REXML::ExternalEntity)

#to_s (REXML::Light::Node)

#to_s (REXML::Node)

#to_s (REXML::NotationDecl)

#to_s (REXML::Output)

#to_s (REXML::ParseException)

#to_s (REXML::Text)

#to_s (REXML::Validation::Event)

#to_s (REXML::Validation::Ref)

#to_s (REXML::Validation::State)

#to_string (REXML::Attribute)

#unnormalize (REXML::Parsers::BaseParser)

#unnormalized (REXML::Entity)

#unshift (REXML::Parent)

#unshift (REXML::Parsers::BaseParser)

#unshift (REXML::Parsers::PullParser)

#validate (REXML::Validation::Validator)

#value (REXML::Attribute)

#value (REXML::CData)

#value (REXML::Entity)

#value (REXML::Text)

#value= (REXML::Text)

#variables= (REXML::XPathParser)

#version (REXML::Document)

#whitespace (REXML::Element)

#wrap (REXML::Text)

#write (REXML::AttlistDecl)

#write (REXML::Attribute)

#write (REXML::CData)

#write (REXML::Comment)

#write (REXML::DTD::EntityDecl)

#write (REXML::DTD::NotationDecl)

#write (REXML::Declaration)

#write (REXML::DocType)

#write (REXML::Document)

#write (REXML::Element)

#write (REXML::Entity)

#write (REXML::ExternalEntity)

#write (REXML::Formatters::Default)

#write (REXML::Instruction)

#write (REXML::NotationDecl)

#write (REXML::Text)

#write (REXML::XMLDecl)

#write_cdata (REXML::Formatters::Default)

#write_cdata (REXML::Formatters::Pretty)

#write_comment (REXML::Formatters::Default)

#write_comment (REXML::Formatters::Pretty)

#write_document (REXML::Formatters::Default)

#write_document (REXML::Formatters::Pretty)

#write_element (REXML::Formatters::Default)

#write_element (REXML::Formatters::Pretty)

#write_element (REXML::Formatters::Transitive)

#write_instruction (REXML::Formatters::Default)

#write_text (REXML::Formatters::Default)

#write_text (REXML::Formatters::Pretty)

#write_text (REXML::Formatters::Transitive)

#write_with_substitution (REXML::Text)

#xml_decl (REXML::Document)

#xmldecl (REXML::SAX2Listener)

#xmldecl (REXML::StreamListener)

#xmldecl (REXML::XMLDecl)

#xmldecl? (REXML::Parsers::PullEvent)

#xpath (REXML::Attribute)

#xpath (REXML::Element)

#xpath (REXML::Text)