Class: LibXML::XML::Reader
- Inherits:
-
Object
- Object
- LibXML::XML::Reader
- Defined in:
- ext/libxml/ruby_xml_reader.c,
ext/libxml/ruby_xml_reader.c
Overview
The XML::Reader class provides a simpler, alternative way of parsing an XML document in contrast to XML::Parser or XML::SaxParser. A XML::Reader instance acts like a cursor going forward in a document stream, stopping at each node it encounters. To advance to the next node, simply cadd XML::Reader#read.
The XML::Reader API closely matches the DOM Core specification and supports namespaces, xml:base, entity handling and DTDs.
To summarize, XML::Reader provides a far simpler API to use versus XML::SaxParser and is more memory efficient than using XML::Parser to create a DOM tree.
Example:
reader = XML::Reader.string("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
reader.read
assert_equal('foo', reader.name)
assert_nil(reader.value)
3.times do |i|
reader.read
assert_equal(XML::Reader::TYPE_ELEMENT, reader.node_type)
assert_equal('bar', reader.name)
reader.read
assert_equal(XML::Reader::TYPE_TEXT, reader.node_type)
assert_equal((i + 1).to_s, reader.value)
reader.read
assert_equal(XML::Reader::TYPE_END_ELEMENT, reader.node_type)
end
You can also parse documents (see XML::Reader.document), strings (see XML::Parser.string) and io objects (see XML::Parser.io).
For a more in depth tutorial, albeit in C, see xmlsoft.org/xmlreader.html.
Constant Summary collapse
- LOADDTD =
Constants
INT2FIX(XML_PARSER_LOADDTD)
- DEFAULTATTRS =
INT2FIX(XML_PARSER_DEFAULTATTRS)
- VALIDATE =
INT2FIX(XML_PARSER_VALIDATE)
- SUBST_ENTITIES =
INT2FIX(XML_PARSER_SUBST_ENTITIES)
- SEVERITY_VALIDITY_WARNING =
INT2FIX(XML_PARSER_SEVERITY_VALIDITY_WARNING)
- SEVERITY_VALIDITY_ERROR =
INT2FIX(XML_PARSER_SEVERITY_VALIDITY_ERROR)
- SEVERITY_WARNING =
INT2FIX(XML_PARSER_SEVERITY_WARNING)
- SEVERITY_ERROR =
INT2FIX(XML_PARSER_SEVERITY_ERROR)
- TYPE_NONE =
INT2FIX(XML_READER_TYPE_NONE)
- TYPE_ELEMENT =
INT2FIX(XML_READER_TYPE_ELEMENT)
- TYPE_ATTRIBUTE =
INT2FIX(XML_READER_TYPE_ATTRIBUTE)
- TYPE_TEXT =
INT2FIX(XML_READER_TYPE_TEXT)
- TYPE_CDATA =
INT2FIX(XML_READER_TYPE_CDATA)
- TYPE_ENTITY_REFERENCE =
INT2FIX(XML_READER_TYPE_ENTITY_REFERENCE)
- TYPE_ENTITY =
INT2FIX(XML_READER_TYPE_ENTITY)
- TYPE_PROCESSING_INSTRUCTION =
INT2FIX(XML_READER_TYPE_PROCESSING_INSTRUCTION)
- TYPE_COMMENT =
INT2FIX(XML_READER_TYPE_COMMENT)
- TYPE_DOCUMENT =
INT2FIX(XML_READER_TYPE_DOCUMENT)
- TYPE_DOCUMENT_TYPE =
INT2FIX(XML_READER_TYPE_DOCUMENT_TYPE)
- TYPE_DOCUMENT_FRAGMENT =
INT2FIX(XML_READER_TYPE_DOCUMENT_FRAGMENT)
- TYPE_NOTATION =
INT2FIX(XML_READER_TYPE_NOTATION)
- TYPE_WHITESPACE =
INT2FIX(XML_READER_TYPE_WHITESPACE)
- TYPE_SIGNIFICANT_WHITESPACE =
INT2FIX(XML_READER_TYPE_SIGNIFICANT_WHITESPACE)
- TYPE_END_ELEMENT =
INT2FIX(XML_READER_TYPE_END_ELEMENT)
- TYPE_END_ENTITY =
INT2FIX(XML_READER_TYPE_END_ENTITY)
- TYPE_XML_DECLARATION =
INT2FIX(XML_READER_TYPE_XML_DECLARATION)
- MODE_INITIAL =
Read states
INT2FIX(XML_TEXTREADER_MODE_INITIAL)
- MODE_INTERACTIVE =
INT2FIX(XML_TEXTREADER_MODE_INTERACTIVE)
- MODE_ERROR =
INT2FIX(XML_TEXTREADER_MODE_ERROR)
- MODE_EOF =
INT2FIX(XML_TEXTREADER_MODE_EOF)
- MODE_CLOSED =
INT2FIX(XML_TEXTREADER_MODE_CLOSED)
- MODE_READING =
INT2FIX(XML_TEXTREADER_MODE_READING)
Class Method Summary collapse
-
.XML::Reader.document(doc) ⇒ XML::Reader
Create an new reader for the specified document.
-
.file(*args) ⇒ Object
Creates a new reader by parsing the specified file or uri.
-
.io(*args) ⇒ Object
Creates a new reader by parsing the specified io object.
-
.string(*args) ⇒ Object
Creates a new reader by parsing the specified string.
Instance Method Summary collapse
-
#[](key) ⇒ Object
Provide the value of the attribute with the specified index (if
key
is an integer) or with the specified name (ifkey
is a string) relative to the containing element, as a string. -
#attribute_count ⇒ Object
Provide the number of attributes of the current node.
-
#base_uri ⇒ Object
Determine the base URI of the node.
-
#byte_consumed ⇒ Object
This method provides the current index of the parser used by the reader, relative to the start of the current entity.
-
#close ⇒ Object
This method releases any resources allocated by the current instance changes the state to Closed and close any underlying input.
-
#column_number ⇒ Numeric
Provide the column number of the current parsing point.
-
#default? ⇒ Boolean
Return whether an Attribute node was generated from the default value defined in the DTD or schema.
-
#depth ⇒ Object
Get the depth of the node in the tree.
-
#document ⇒ Object
Hacking interface that provides access to the current document being accessed by the reader.
-
#empty_element? ⇒ Boolean
Check if the current node is empty.
-
#encoding ⇒ XML::Encoding::UTF_8
Returns the encoding of the document being read.
-
#expand ⇒ Object
Returns the current node and its full subtree.
-
#get_attribute(localName) ⇒ Object
Provide the value of the attribute with the specified name relative to the containing element.
-
#get_attribute_no(index) ⇒ Object
Provide the value of the attribute with the specified index relative to the containing element.
- #get_attribute_ns(name, ns) ⇒ Object
-
#has_attributes? ⇒ Boolean
Get whether the node has attributes.
-
#has_value? ⇒ Boolean
Get whether the node can have a text value.
-
#line_number ⇒ Numeric
Provide the line number of the current parsing point.
-
#local_name ⇒ Object
Return the local name of the node.
-
#lookup_namespace(prefix) ⇒ Object
Resolve a namespace prefix in the scope of the current element.
-
#move_to_attribute(localName) ⇒ Object
Move the position of the current instance to the attribute with the specified name relative to the containing element.
-
#move_to_attribute_no(index) ⇒ Object
Move the position of the current instance to the attribute with the specified index relative to the containing element.
-
#move_to_attribute_ns(localName, namespaceURI) ⇒ Object
Move the position of the current instance to the attribute with the specified name and namespace relative to the containing element.
-
#move_to_element ⇒ Object
Move the position of the current instance to the node that contains the current attribute node.
-
#move_to_first_attribute ⇒ Object
Move the position of the current instance to the first attribute associated with the current node.
-
#move_to_next_attribute ⇒ Object
Move the position of the current instance to the next attribute associated with the current node.
-
#name ⇒ Object
Return the qualified name of the node.
-
#namespace_declaration? ⇒ Boolean
Determine whether the current node is a namespace declaration rather than a regular attribute.
-
#namespace_uri ⇒ Object
Determine the namespace URI of the node.
-
#next ⇒ Object
Skip to the node following the current one in document order while avoiding the subtree if any.
-
#next_sibling ⇒ Object
Skip to the node following the current one in document order while avoiding the subtree if any.
-
#node ⇒ XML::Node
Returns the reader’s current node.
-
#node_type ⇒ Object
Get the node type of the current node.
-
#normalization ⇒ Object
The value indicating whether to normalize white space and attribute values.
-
#prefix ⇒ Object
Get a shorthand reference to the namespace associated with the node.
-
#quote_char ⇒ String
Get the quotation mark character used to enclose the value of an attribute, as an integer value (and -1 in case of error).
-
#read ⇒ Object
Causes the reader to move to the next node in the stream, exposing its properties.
-
#read_attribute_value ⇒ Object
Parse an attribute value into one or more Text and EntityReference nodes.
-
#read_inner_xml ⇒ Object
Read the contents of the current node, including child nodes and markup.
-
#read_outer_xml ⇒ Object
Read the contents of the current node, including child nodes and markup.
-
#read_state ⇒ Object
Get the read state of the reader.
-
#read_string ⇒ String
Read the contents of an element or a text node as a string.
-
#relax_ng_validate(rng) ⇒ Boolean
Use RelaxNG to validate the document as it is processed.
-
#schema_validate(schema) ⇒ Boolean
Use W3C XSD schema to validate the document as it is processed.
-
#standalone ⇒ Object
Determine the standalone status of the document being read.
-
#valid? ⇒ Boolean
Retrieve the validity status from the parser context.
-
#value ⇒ Object
Provide the text value of the node if present.
-
#xml_lang ⇒ Object
Get the xml:lang scope within which the node resides.
-
#xml_version ⇒ Object
Determine the XML version of the document being read.
Class Method Details
.XML::Reader.document(doc) ⇒ XML::Reader
Create an new reader for the specified document.
93 94 95 96 97 98 99 100 101 102 103 104 105 106 |
# File 'ext/libxml/ruby_xml_reader.c', line 93
VALUE rxml_reader_document(VALUE klass, VALUE doc)
{
xmlDocPtr xdoc;
xmlTextReaderPtr xreader;
Data_Get_Struct(doc, xmlDoc, xdoc);
xreader = xmlReaderWalker(xdoc);
if (xreader == NULL)
rxml_raise(xmlGetLastError());
return rxml_reader_wrap(xreader);
}
|
.XML::Reader.file(path) ⇒ XML::Reader .XML::Reader.file(path, : encoding) ⇒ XML::Encoding::UTF_8
Creates a new reader by parsing the specified file or uri.
You may provide an optional hash table to control how the parsing is performed. Valid options are:
encoding - The document encoding, defaults to nil. Valid values
are the encoding constants defined on XML::Encoding.
options - Controls the execution of the parser, defaults to 0.
Valid values are the constants defined on
XML::Parser::Options. Mutliple options can be combined
by using Bitwise OR (|).
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 |
# File 'ext/libxml/ruby_xml_reader.c', line 125
static VALUE rxml_reader_file(int argc, VALUE *argv, VALUE klass)
{
VALUE path;
VALUE options;
rb_scan_args(argc, argv, "11", &path, &options);
Check_Type(path, T_STRING);
const char* xencoding = NULL;
int xoptions = 0;
if (!NIL_P(options))
{
Check_Type(options, T_HASH);
VALUE encoding = rb_hash_aref(options, BASE_URI_SYMBOL);
xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
VALUE parserOptions = rb_hash_aref(options, OPTIONS_SYMBOL);
xoptions = NIL_P(parserOptions) ? 0 : NUM2INT(parserOptions);
}
xmlTextReaderPtr xreader = xmlReaderForFile(StringValueCStr(path), xencoding, xoptions);
// Unfortunately libxml2 does not set xmlLastError and just returns a null reader
if (xreader == NULL)
rb_syserr_fail(ENOENT, StringValueCStr(path));
return rxml_reader_wrap(xreader);
}
|
.XML::Reader.io(io) ⇒ XML::Reader .XML::Reader.io(io, : encoding) ⇒ XML::Encoding::UTF_8
Creates a new reader by parsing the specified io object.
You may provide an optional hash table to control how the parsing is performed. Valid options are:
base_uri - The base url for the parsed document.
encoding - The document encoding, defaults to nil. Valid values
are the encoding constants defined on XML::Encoding.
options - Controls the execution of the parser, defaults to 0.
Valid values are the constants defined on
XML::Parser::Options. Mutliple options can be combined
by using Bitwise OR (|).
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 |
# File 'ext/libxml/ruby_xml_reader.c', line 174
static VALUE rxml_reader_io(int argc, VALUE *argv, VALUE klass)
{
xmlTextReaderPtr xreader;
VALUE result;
VALUE io;
VALUE options;
char *xbaseurl = NULL;
const char *xencoding = NULL;
int xoptions = 0;
rb_scan_args(argc, argv, "11", &io, &options);
if (!NIL_P(options))
{
VALUE baseurl = Qnil;
VALUE encoding = Qnil;
VALUE parserOptions = Qnil;
Check_Type(options, T_HASH);
baseurl = rb_hash_aref(options, BASE_URI_SYMBOL);
xbaseurl = NIL_P(baseurl) ? NULL : StringValueCStr(baseurl);
encoding = rb_hash_aref(options, ENCODING_SYMBOL);
xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
parserOptions = rb_hash_aref(options, OPTIONS_SYMBOL);
xoptions = NIL_P(parserOptions) ? 0 : NUM2INT(parserOptions);
}
xreader = xmlReaderForIO((xmlInputReadCallback) rxml_read_callback, NULL,
(void *) io,
xbaseurl, xencoding, xoptions);
if (xreader == NULL)
rxml_raise(xmlGetLastError());
result = rxml_reader_wrap(xreader);
/* Attach io object to parser so it won't get freed.*/
rb_ivar_set(result, IO_ATTR, io);
return result;
}
|
.XML::Reader.string(io) ⇒ XML::Reader .XML::Reader.string(io, : encoding) ⇒ XML::Encoding::UTF_8
Creates a new reader by parsing the specified string.
You may provide an optional hash table to control how the parsing is performed. Valid options are:
base_uri - The base url for the parsed document.
encoding - The document encoding, defaults to nil. Valid values
are the encoding constants defined on XML::Encoding.
options - Controls the execution of the parser, defaults to 0.
Valid values are the constants defined on
XML::Parser::Options. Mutliple options can be combined
by using Bitwise OR (|).
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 |
# File 'ext/libxml/ruby_xml_reader.c', line 237
static VALUE rxml_reader_string(int argc, VALUE *argv, VALUE klass)
{
xmlTextReaderPtr xreader;
VALUE string;
VALUE options;
char *xbaseurl = NULL;
const char *xencoding = NULL;
int xoptions = 0;
rb_scan_args(argc, argv, "11", &string, &options);
Check_Type(string, T_STRING);
if (!NIL_P(options))
{
VALUE baseurl = Qnil;
VALUE encoding = Qnil;
VALUE parserOptions = Qnil;
Check_Type(options, T_HASH);
baseurl = rb_hash_aref(options, BASE_URI_SYMBOL);
xbaseurl = NIL_P(baseurl) ? NULL : StringValueCStr(baseurl);
encoding = rb_hash_aref(options, ENCODING_SYMBOL);
xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
parserOptions = rb_hash_aref(options, OPTIONS_SYMBOL);
xoptions = NIL_P(parserOptions) ? 0 : NUM2INT(parserOptions);
}
xreader = xmlReaderForMemory(StringValueCStr(string), (int)RSTRING_LEN(string),
xbaseurl, xencoding, xoptions);
if (xreader == NULL)
rxml_raise(xmlGetLastError());
return rxml_reader_wrap(xreader);
}
|
Instance Method Details
#[](key) ⇒ Object
Provide the value of the attribute with the specified index (if key
is an integer) or with the specified name (if key
is a string) relative to the containing element, as a string.
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 |
# File 'ext/libxml/ruby_xml_reader.c', line 871
static VALUE rxml_reader_attribute(VALUE self, VALUE key)
{
VALUE result = Qnil;
xmlChar *xattr;
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
if (TYPE(key) == T_FIXNUM)
{
xattr = xmlTextReaderGetAttributeNo(xReader, FIX2INT(key));
}
else
{
xattr = xmlTextReaderGetAttribute(xReader, (const xmlChar *) StringValueCStr(key));
}
if (xattr)
{
result = rxml_new_cstr(xattr, xencoding);
xmlFree(xattr);
}
return result;
}
|
#attribute_count ⇒ Object
Provide the number of attributes of the current node.
676 677 678 679 680 |
# File 'ext/libxml/ruby_xml_reader.c', line 676
static VALUE rxml_reader_attr_count(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderAttributeCount(xreader));
}
|
#base_uri ⇒ Object
Determine the base URI of the node.
714 715 716 717 718 719 720 721 |
# File 'ext/libxml/ruby_xml_reader.c', line 714
static VALUE rxml_reader_base_uri(VALUE self)
{
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *result = xmlTextReaderConstBaseUri(xReader);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));
}
|
#byte_consumed ⇒ Object
This method provides the current index of the parser used by the reader, relative to the start of the current entity.
1046 1047 1048 1049 1050 1051 |
# File 'ext/libxml/ruby_xml_reader.c', line 1046
static VALUE
rxml_reader_byte_consumed(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return LONG2NUM(xmlTextReaderByteConsumed(xreader));
}
|
#close ⇒ Object
This method releases any resources allocated by the current instance changes the state to Closed and close any underlying input.
283 284 285 286 287 |
# File 'ext/libxml/ruby_xml_reader.c', line 283
static VALUE rxml_reader_close(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderClose(xreader));
}
|
#column_number ⇒ Numeric
Provide the column number of the current parsing point.
1061 1062 1063 1064 1065 1066 |
# File 'ext/libxml/ruby_xml_reader.c', line 1061
static VALUE
rxml_reader_column_number(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2NUM(xmlTextReaderGetParserColumnNumber(xreader));
}
|
#default? ⇒ Boolean
Return whether an Attribute node was generated from the default value defined in the DTD or schema.
1089 1090 1091 1092 1093 |
# File 'ext/libxml/ruby_xml_reader.c', line 1089
static VALUE rxml_reader_default(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return xmlTextReaderIsDefault(xreader) ? Qtrue : Qfalse;
}
|
#depth ⇒ Object
Get the depth of the node in the tree.
774 775 776 777 778 |
# File 'ext/libxml/ruby_xml_reader.c', line 774
static VALUE rxml_reader_depth(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderDepth(xreader));
}
|
#document ⇒ Object
Hacking interface that provides access to the current document being accessed by the reader. NOTE: as a result of this call, the reader will not destroy the associated XML document. Instead, it will be destroyed when the returned document goes out of scope.
Returns: document
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 |
# File 'ext/libxml/ruby_xml_reader.c', line 1019
static VALUE rxml_reader_doc(VALUE self)
{
VALUE result = Qnil;
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
xmlDocPtr xdoc = xmlTextReaderCurrentDoc(xreader);
if (!xdoc)
rb_raise(rb_eRuntimeError, "The reader does not have a document. Did you forget to call read?");
result = rxml_document_wrap(xdoc);
// And now hook in a mark function to keep the document alive as long as the reader is valid
RDATA(self)->dmark = (RUBY_DATA_FUNC)rxml_reader_mark;
return result;
}
|
#empty_element? ⇒ Boolean
Check if the current node is empty.
1114 1115 1116 1117 1118 |
# File 'ext/libxml/ruby_xml_reader.c', line 1114
static VALUE rxml_reader_empty_element(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return xmlTextReaderIsEmptyElement(xreader) ? Qtrue : Qfalse;
}
|
#encoding ⇒ XML::Encoding::UTF_8
Returns the encoding of the document being read. Note you first have to read data from the reader for encoding to return a value
reader = XML::Reader.file(XML_FILE)
assert_nil(reader.encoding)
reader.read
assert_equal(XML::Encoding::UTF_8, reader.encoding)
In addition, libxml always appears to return nil for the encoding when parsing strings.
698 699 700 701 702 703 704 705 706 |
# File 'ext/libxml/ruby_xml_reader.c', line 698
static VALUE rxml_reader_encoding(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xreader);
if (xencoding)
return INT2NUM(xmlParseCharEncoding((const char*)xencoding));
else
return INT2NUM(XML_CHAR_ENCODING_NONE);
}
|
#expand ⇒ Object
Returns the current node and its full subtree. Note the returned node is valid ONLY until the next read call. If you would like to preserve the node, or search it via xpath, call reader.doc first.
989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 |
# File 'ext/libxml/ruby_xml_reader.c', line 989
static VALUE rxml_reader_expand(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
xmlNodePtr xnode = xmlTextReaderExpand(xreader);
if (!xnode)
{
return Qnil;
}
else
{
/* We cannot call rxml_node_wrap here because its sets up a mark function
for the node. But according to the libxml docs (http://xmlsoft.org/html/libxml-xmlreader.html#xmlTextReaderExpand)
this is only valid until the next xmlTextReaderRead call. At that point the node is freed (from reading
the libxml2 source code. So don't set a mark or free function, because they will get called in the next
garbage collection run and cause a segfault.*/
return Data_Wrap_Struct(cXMLNode, NULL, NULL, xnode);
}
}
|
#get_attribute(localName) ⇒ Object
Provide the value of the attribute with the specified name relative to the containing element.
902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 |
# File 'ext/libxml/ruby_xml_reader.c', line 902
static VALUE rxml_reader_get_attribute(VALUE self, VALUE name)
{
VALUE result = Qnil;
xmlChar *xattr;
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
xattr = xmlTextReaderGetAttribute(xReader, (const xmlChar *) StringValueCStr(name));
if (xattr)
{
result = rxml_new_cstr(xattr, xencoding);
xmlFree(xattr);
}
return result;
}
|
#get_attribute_no(index) ⇒ Object
Provide the value of the attribute with the specified index relative to the containing element.
925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 |
# File 'ext/libxml/ruby_xml_reader.c', line 925
static VALUE rxml_reader_get_attribute_no(VALUE self, VALUE index)
{
VALUE result = Qnil;
xmlChar *xattr;
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
xattr = xmlTextReaderGetAttributeNo(xReader, FIX2INT(index));
if (xattr)
{
result = rxml_new_cstr(xattr, xencoding);
xmlFree(xattr);
}
return result;
}
|
#get_attribute_ns(name, ns) ⇒ Object
941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 |
# File 'ext/libxml/ruby_xml_reader.c', line 941
static VALUE rxml_reader_get_attribute_ns(VALUE self, VALUE name, VALUE ns)
{
VALUE result = Qnil;
xmlChar *xattr;
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
xattr = xmlTextReaderGetAttributeNs(xReader,
(const xmlChar *) StringValueCStr(name),
(const xmlChar *) StringValueCStr(ns));
if (xattr)
{
result = rxml_new_cstr(xattr, xencoding);
xmlFree(xattr);
}
return result;
}
|
#has_attributes? ⇒ Boolean
Get whether the node has attributes.
845 846 847 848 849 |
# File 'ext/libxml/ruby_xml_reader.c', line 845
static VALUE rxml_reader_has_attributes(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return xmlTextReaderHasAttributes(xreader) ? Qtrue : Qfalse;
}
|
#has_value? ⇒ Boolean
Get whether the node can have a text value.
857 858 859 860 861 |
# File 'ext/libxml/ruby_xml_reader.c', line 857
static VALUE rxml_reader_has_value(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return xmlTextReaderHasValue(xreader) ? Qtrue : Qfalse;
}
|
#line_number ⇒ Numeric
Provide the line number of the current parsing point.
1074 1075 1076 1077 1078 1079 |
# File 'ext/libxml/ruby_xml_reader.c', line 1074
static VALUE
rxml_reader_line_number(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2NUM(xmlTextReaderGetParserLineNumber(xreader));
}
|
#local_name ⇒ Object
Return the local name of the node.
661 662 663 664 665 666 667 668 |
# File 'ext/libxml/ruby_xml_reader.c', line 661
static VALUE rxml_reader_local_name(VALUE self)
{
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *result = xmlTextReaderConstLocalName(xReader);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));
}
|
#lookup_namespace(prefix) ⇒ Object
Resolve a namespace prefix in the scope of the current element. To return the default namespace, specify nil as prefix
.
966 967 968 969 970 971 972 973 974 975 976 977 978 979 |
# File 'ext/libxml/ruby_xml_reader.c', line 966
static VALUE rxml_reader_lookup_namespace(VALUE self, VALUE prefix)
{
VALUE result = Qnil;
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *xnamespace = xmlTextReaderLookupNamespace(xReader, (const xmlChar *) StringValueCStr(prefix));
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
if (xnamespace)
{
result = rxml_new_cstr(xnamespace, xencoding);
xmlFree((void *)xnamespace);
}
return result;
}
|
#move_to_attribute(localName) ⇒ Object
Move the position of the current instance to the attribute with the specified name relative to the containing element.
314 315 316 317 318 319 320 321 322 323 324 |
# File 'ext/libxml/ruby_xml_reader.c', line 314
static VALUE rxml_reader_move_to_attr(VALUE self, VALUE val)
{
int ret;
xmlTextReaderPtr xreader;
xreader = rxml_text_reader_get(self);
ret = xmlTextReaderMoveToAttribute(xreader,
(const xmlChar *) StringValueCStr(val));
return INT2FIX(ret);
}
|
#move_to_attribute_no(index) ⇒ Object
Move the position of the current instance to the attribute with the specified index relative to the containing element.
296 297 298 299 300 301 302 303 304 305 |
# File 'ext/libxml/ruby_xml_reader.c', line 296
static VALUE rxml_reader_move_to_attr_no(VALUE self, VALUE index)
{
int ret;
xmlTextReaderPtr xreader;
xreader = rxml_text_reader_get(self);
ret = xmlTextReaderMoveToAttributeNo(xreader, FIX2INT(index));
return INT2FIX(ret);
}
|
#move_to_attribute_ns(localName, namespaceURI) ⇒ Object
Move the position of the current instance to the attribute with the specified name and namespace relative to the containing element.
333 334 335 336 337 338 339 340 341 342 343 344 |
# File 'ext/libxml/ruby_xml_reader.c', line 333
static VALUE rxml_reader_move_to_attr_ns(VALUE self, VALUE name, VALUE ns)
{
int ret;
xmlTextReaderPtr xreader;
xreader = rxml_text_reader_get(self);
ret = xmlTextReaderMoveToAttributeNs(xreader,
(const xmlChar *) StringValueCStr(name),
(const xmlChar *) StringValueCStr(ns));
return INT2FIX(ret);
}
|
#move_to_element ⇒ Object
Move the position of the current instance to the node that contains the current attribute node.
379 380 381 382 383 |
# File 'ext/libxml/ruby_xml_reader.c', line 379
static VALUE rxml_reader_move_to_element(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderMoveToElement(xreader));
}
|
#move_to_first_attribute ⇒ Object
Move the position of the current instance to the first attribute associated with the current node.
353 354 355 356 357 |
# File 'ext/libxml/ruby_xml_reader.c', line 353
static VALUE rxml_reader_move_to_first_attr(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderMoveToFirstAttribute(xreader));
}
|
#move_to_next_attribute ⇒ Object
Move the position of the current instance to the next attribute associated with the current node.
366 367 368 369 370 |
# File 'ext/libxml/ruby_xml_reader.c', line 366
static VALUE rxml_reader_move_to_next_attr(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderMoveToNextAttribute(xreader));
}
|
#name ⇒ Object
Return the qualified name of the node.
646 647 648 649 650 651 652 653 |
# File 'ext/libxml/ruby_xml_reader.c', line 646
static VALUE rxml_reader_name(VALUE self)
{
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *result = xmlTextReaderConstName(xReader);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));
}
|
#namespace_declaration? ⇒ Boolean
Determine whether the current node is a namespace declaration rather than a regular attribute.
1102 1103 1104 1105 1106 |
# File 'ext/libxml/ruby_xml_reader.c', line 1102
static VALUE rxml_reader_namespace_declaration(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return xmlTextReaderIsNamespaceDecl(xreader) ? Qtrue : Qfalse;
}
|
#namespace_uri ⇒ Object
Determine the namespace URI of the node.
729 730 731 732 733 734 735 736 |
# File 'ext/libxml/ruby_xml_reader.c', line 729
static VALUE rxml_reader_namespace_uri(VALUE self)
{
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *result = xmlTextReaderConstNamespaceUri(xReader);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));
}
|
#next ⇒ Object
Skip to the node following the current one in document order while avoiding the subtree if any.
392 393 394 395 396 |
# File 'ext/libxml/ruby_xml_reader.c', line 392
static VALUE rxml_reader_next(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderNext(xreader));
}
|
#next_sibling ⇒ Object
Skip to the node following the current one in document order while avoiding the subtree if any. Currently implemented only for Readers built on a document.
406 407 408 409 410 |
# File 'ext/libxml/ruby_xml_reader.c', line 406
static VALUE rxml_reader_next_sibling(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderNextSibling(xreader));
}
|
#node ⇒ XML::Node
Returns the reader’s current node. It will return nil if Reader#read has not yet been called. WARNING - Using this method is dangerous because the the node may be destroyed on the next #read.
421 422 423 424 425 426 |
# File 'ext/libxml/ruby_xml_reader.c', line 421
static VALUE rxml_reader_node(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
xmlNodePtr xnode = xmlTextReaderCurrentNode(xreader);
return xnode ? rxml_node_wrap(xnode) : Qnil;
}
|
#node_type ⇒ Object
Get the node type of the current node. Reference: dotgnu.org/pnetlib-doc/System/Xml/XmlNodeType.html
435 436 437 438 439 |
# File 'ext/libxml/ruby_xml_reader.c', line 435
static VALUE rxml_reader_node_type(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderNodeType(xreader));
}
|
#normalization ⇒ Object
The value indicating whether to normalize white space and attribute values. Since attribute value and end of line normalizations are a MUST in the XML specification only the value true is accepted. The broken bahaviour of accepting out of range character entities like � is of course not supported either.
Return 1 or -1 in case of error.
453 454 455 456 457 |
# File 'ext/libxml/ruby_xml_reader.c', line 453
static VALUE rxml_reader_normalization(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderNormalization(xreader));
}
|
#prefix ⇒ Object
Get a shorthand reference to the namespace associated with the node.
759 760 761 762 763 764 765 766 |
# File 'ext/libxml/ruby_xml_reader.c', line 759
static VALUE rxml_reader_prefix(VALUE self)
{
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *result = xmlTextReaderConstPrefix(xReader);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));
}
|
#quote_char ⇒ String
Get the quotation mark character used to enclose the value of an attribute, as an integer value (and -1 in case of error).
787 788 789 790 791 |
# File 'ext/libxml/ruby_xml_reader.c', line 787
static VALUE rxml_reader_quote_char(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderQuoteChar(xreader));
}
|
#read ⇒ Object
Causes the reader to move to the next node in the stream, exposing its properties.
Returns true if a node was successfully read or false if there are no more nodes to read. On errors, an exception is raised.
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 |
# File 'ext/libxml/ruby_xml_reader.c', line 467
static VALUE rxml_reader_read(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
int result = xmlTextReaderRead(xreader);
switch(result)
{
case -1:
rxml_raise(xmlGetLastError());
return Qnil;
break;
case 0:
return Qfalse;
case 1:
return Qtrue;
default:
rb_raise(rb_eRuntimeError,
"xmlTextReaderRead did not return -1, 0 or 1. Return value was: %d", result);
}
}
|
#read_attribute_value ⇒ Object
Parse an attribute value into one or more Text and EntityReference nodes.
Return 1 in case of success, 0 if the reader was not positionned on an attribute node or all the attribute values have been read, or -1 in case of error.
497 498 499 500 501 |
# File 'ext/libxml/ruby_xml_reader.c', line 497
static VALUE rxml_reader_read_attr_value(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderReadAttributeValue(xreader));
}
|
#read_inner_xml ⇒ Object
Read the contents of the current node, including child nodes and markup.
Return a string containing the XML content, or nil if the current node is neither an element nor attribute, or has no child nodes.
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 |
# File 'ext/libxml/ruby_xml_reader.c', line 512
static VALUE rxml_reader_read_inner_xml(VALUE self)
{
VALUE result = Qnil;
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
xmlChar *xml = xmlTextReaderReadInnerXml(xReader);
if (xml)
{
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
result = rxml_new_cstr( xml, xencoding);
xmlFree(xml);
}
return result;
}
|
#read_outer_xml ⇒ Object
Read the contents of the current node, including child nodes and markup.
Return a string containing the XML content, or nil if the current node is neither an element nor attribute, or has no child nodes.
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 |
# File 'ext/libxml/ruby_xml_reader.c', line 538
static VALUE rxml_reader_read_outer_xml(VALUE self)
{
VALUE result = Qnil;
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
xmlChar *xml = xmlTextReaderReadOuterXml(xReader);
if (xml)
{
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
result = rxml_new_cstr( xml, xencoding);
xmlFree(xml);
}
return result;
}
|
#read_state ⇒ Object
Get the read state of the reader.
561 562 563 564 565 |
# File 'ext/libxml/ruby_xml_reader.c', line 561
static VALUE rxml_reader_read_state(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderReadState(xreader));
}
|
#read_string ⇒ String
Read the contents of an element or a text node as a string.
Return a string containing the contents of the Element or Text node, or nil if the reader is positioned on any other type of node.
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 |
# File 'ext/libxml/ruby_xml_reader.c', line 576
static VALUE rxml_reader_read_string(VALUE self)
{
VALUE result = Qnil;
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
xmlChar *xml = xmlTextReaderReadString(xReader);
if (xml)
{
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
result = rxml_new_cstr( xml, xencoding);
xmlFree(xml);
}
return result;
}
|
#relax_ng_validate(rng) ⇒ Boolean
Use RelaxNG to validate the document as it is processed. Activation is only possible before the first read. If rng
is nil, the RelaxNG validation is desactivated.
Return true in case the RelaxNG validation could be (des)activated and false in case of error.
604 605 606 607 608 609 610 611 612 613 |
# File 'ext/libxml/ruby_xml_reader.c', line 604
static VALUE rxml_reader_relax_ng_validate(VALUE self, VALUE rng)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
xmlRelaxNGPtr xrelax;
int status;
Data_Get_Struct(rng, xmlRelaxNG, xrelax);
status = xmlTextReaderRelaxNGSetSchema(xreader, xrelax);
return (status == 0 ? Qtrue : Qfalse);
}
|
#schema_validate(schema) ⇒ Boolean
Use W3C XSD schema to validate the document as it is processed. Activation is only possible before the first read. If schema
is nil, then XML Schema validation is deactivated.
Return false if if the schema’s validation could be (de)activated and true otherwise.
627 628 629 630 631 632 633 634 635 636 637 |
# File 'ext/libxml/ruby_xml_reader.c', line 627
static VALUE
rxml_reader_schema_validate(VALUE self, VALUE xsd)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
xmlSchemaPtr xschema;
int status;
Data_Get_Struct(xsd, xmlSchema, xschema);
status = xmlTextReaderSetSchema(xreader, xschema);
return (status == 0 ? Qtrue : Qfalse);
}
|
#standalone ⇒ Object
Determine the standalone status of the document being read.
Return 1 if the document was declared to be standalone, 0 if it was declared to be not standalone, or -1 if the document did not specify its standalone status or in case of error.
803 804 805 806 807 |
# File 'ext/libxml/ruby_xml_reader.c', line 803
static VALUE rxml_reader_standalone(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderStandalone(xreader));
}
|
#valid? ⇒ Boolean
Retrieve the validity status from the parser context.
1126 1127 1128 1129 1130 |
# File 'ext/libxml/ruby_xml_reader.c', line 1126
static VALUE rxml_reader_valid(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return xmlTextReaderIsValid(xreader) ? Qtrue : Qfalse;
}
|
#value ⇒ Object
Provide the text value of the node if present.
744 745 746 747 748 749 750 751 |
# File 'ext/libxml/ruby_xml_reader.c', line 744
static VALUE rxml_reader_value(VALUE self)
{
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *result = xmlTextReaderConstValue(xReader);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));
}
|
#xml_lang ⇒ Object
Get the xml:lang scope within which the node resides.
815 816 817 818 819 820 821 822 |
# File 'ext/libxml/ruby_xml_reader.c', line 815
static VALUE rxml_reader_xml_lang(VALUE self)
{
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *result = xmlTextReaderConstXmlLang(xReader);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));
}
|
#xml_version ⇒ Object
Determine the XML version of the document being read.
830 831 832 833 834 835 836 837 |
# File 'ext/libxml/ruby_xml_reader.c', line 830
static VALUE rxml_reader_xml_version(VALUE self)
{
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *result = xmlTextReaderConstXmlVersion(xReader);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));
}
|