Class: LibXML::XML::Writer

Inherits:
Object
  • Object
show all
Defined in:
ext/libxml/ruby_xml_writer.c,
ext/libxml/ruby_xml_writer.c

Overview

The XML::Writer class provides a simpler, alternative way to build a valid XML document from scratch (forward-only) compared to a DOM approach (based on XML::Document class).

For a more in depth tutorial, albeit in C, see xmlsoft.org/xmlwriter.html

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.XML::Writer::document ⇒ XML::Writer

Creates a XML::Writer which will write into an in memory XML::Document

Returns:



186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
 
# File 'ext/libxml/ruby_xml_writer.c', line 186

static VALUE rxml_writer_doc(VALUE klass)
{
    xmlDocPtr doc;
    rxml_writer_object *rwo;

    rwo = ALLOC(rxml_writer_object);
    rwo->buffer = NULL;
    rwo->output = Qnil;
    rwo->output_type = RXMLW_OUTPUT_DOC;
    if (NULL == (rwo->writer = xmlNewTextWriterDoc(&doc, 0))) {
        rxml_raise(&xmlLastError);
    }
    rwo->output = rxml_document_wrap(doc);

    return rxml_writer_wrap(rwo);
}

.XML::Writer::file(path) ⇒ XML::Writer

Creates a XML::Writer object which will write XML into the file with the given name.

Returns:



143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'ext/libxml/ruby_xml_writer.c', line 143

static VALUE rxml_writer_file(VALUE klass, VALUE filename)
{
    rxml_writer_object *rwo;

    rwo = ALLOC(rxml_writer_object);
    rwo->output = Qnil;
    rwo->buffer = NULL;
    rwo->output_type = RXMLW_OUTPUT_NONE;
    if (NULL == (rwo->writer = xmlNewTextWriterFilename(StringValueCStr(filename), 0))) {
        rxml_raise(&xmlLastError);
    }

    return rxml_writer_wrap(rwo);
}

.XML::Writer::io(io) ⇒ XML::Writer

Creates a XML::Writer which will write XML directly into an IO object.

Returns:



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'ext/libxml/ruby_xml_writer.c', line 107

static VALUE rxml_writer_io(VALUE klass, VALUE io)
{
#if 0
typedef int (*xmlOutputCloseCallback)(void * context);
typedef int (*xmlOutputWriteCallback)(void * context, const char * buffer, int len);

ssize_t rb_io_bufwrite(VALUE io, const void *buf, size_t size);

xmlOutputBufferPtr xmlOutputBufferCreateIO(xmlOutputWriteCallback iowrite, xmlOutputCloseCallback ioclose, void * ioctx, xmlCharEncodingHandlerPtr encoder)

xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char * name);
#endif
    xmlOutputBufferPtr out;
    rxml_writer_object *rwo;

    rwo = ALLOC(rxml_writer_object);
    rwo->output = io;
    rwo->buffer = NULL;
    rwo->output_type = RXMLW_OUTPUT_IO;
    if (NULL == (out = xmlOutputBufferCreateIO(rxml_write_callback, NULL, (void *) io, NULL))) {
        rxml_raise(&xmlLastError);
    }
    if (NULL == (rwo->writer = xmlNewTextWriter(out))) {
        rxml_raise(&xmlLastError);
    }

    return rxml_writer_wrap(rwo);
}

.XML::Writer::string ⇒ XML::Writer

Creates a XML::Writer which will write XML into memory, as string.

Returns:



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'ext/libxml/ruby_xml_writer.c', line 163

static VALUE rxml_writer_string(VALUE klass)
{
    rxml_writer_object *rwo;

    rwo = ALLOC(rxml_writer_object);
    rwo->output = Qnil;
    rwo->output_type = RXMLW_OUTPUT_STRING;
    if (NULL == (rwo->buffer = xmlBufferCreate())) {
        rxml_raise(&xmlLastError);
    }
    if (NULL == (rwo->writer = xmlNewTextWriterMemory(rwo->buffer, 0))) {
        xmlBufferFree(rwo->buffer);
        rxml_raise(&xmlLastError);
    }

    return rxml_writer_wrap(rwo);
}

Instance Method Details

#end_attribute ⇒ Object

Ends an attribute, namespaced or not. Returns false on failure.



595
596
597
598
 
# File 'ext/libxml/ruby_xml_writer.c', line 595

static VALUE rxml_writer_end_attribute(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterEndAttribute);
}

#end_cdata ⇒ Object

Ends current CDATA section. Returns false on failure.



690
691
692
693
 
# File 'ext/libxml/ruby_xml_writer.c', line 690

static VALUE rxml_writer_end_cdata(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterEndCDATA);
}

#end_comment ⇒ Object

Ends current comment, returns false on failure. Note: libxml2 >= 2.6.7 required



618
619
620
621
 
# File 'ext/libxml/ruby_xml_writer.c', line 618

static VALUE rxml_writer_end_comment(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterEndComment);
}

#end_document ⇒ Object

Ends current document. Returns false on failure.



744
745
746
747
 
# File 'ext/libxml/ruby_xml_writer.c', line 744

static VALUE rxml_writer_end_document(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterEndDocument);
}

#end_dtd ⇒ Object

Ends current DTD, returns false on failure.



825
826
827
828
 
# File 'ext/libxml/ruby_xml_writer.c', line 825

static VALUE rxml_writer_end_dtd(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterEndDTD);
}

#end_dtd_attlist ⇒ Object

Ends current DTD attribute list, returns false on failure.



845
846
847
848
 
# File 'ext/libxml/ruby_xml_writer.c', line 845

static VALUE rxml_writer_end_dtd_attlist(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterEndDTDAttlist);
}

#end_dtd_element ⇒ Object

Ends current DTD element, returns false on failure.



855
856
857
858
 
# File 'ext/libxml/ruby_xml_writer.c', line 855

static VALUE rxml_writer_end_dtd_element(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterEndDTDElement);
}

#end_dtd_entity ⇒ Object

Ends current DTD entity, returns false on failure.



835
836
837
838
 
# File 'ext/libxml/ruby_xml_writer.c', line 835

static VALUE rxml_writer_end_dtd_entity(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterEndDTDEntity);
}

#end_element ⇒ Object

Ends current element, namespaced or not. Returns false on failure.



658
659
660
661
 
# File 'ext/libxml/ruby_xml_writer.c', line 658

static VALUE rxml_writer_end_element(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterEndElement);
}

#end_pi ⇒ Object

Ends current processing instruction. Returns false on failure.



764
765
766
767
 
# File 'ext/libxml/ruby_xml_writer.c', line 764

static VALUE rxml_writer_end_pi(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterEndPI);
}

#flush ⇒ Object

Flushes the output buffer.



210
211
212
213
214
215
216
217
218
219
 
# File 'ext/libxml/ruby_xml_writer.c', line 210

static VALUE rxml_writer_flush(VALUE self)
{
    int ret;
    rxml_writer_object *rwo;

    rwo = rxml_textwriter_get(self);
    ret = xmlTextWriterFlush(rwo->writer);

    return (-1 == ret ? Qfalse : Qtrue);
}

#write_full_end_element ⇒ Object

Ends current element, namespaced or not. Returns false on failure. This method writes an end tag even if the element is empty (<foo></foo>), end_element does not (<foo/>).



670
671
672
673
 
# File 'ext/libxml/ruby_xml_writer.c', line 670

static VALUE rxml_writer_full_end_element(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterFullEndElement);
}

#result ⇒ (XML::Document|"string"|nil)

Returns the associated result object to the XML::Writer creation. A String for a XML::Writer object created with XML::Writer::string, a XML::Document with XML::Writer::document, etc.

Returns:



228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'ext/libxml/ruby_xml_writer.c', line 228

static VALUE rxml_writer_result(VALUE self)
{
    VALUE ret;
    rxml_writer_object *rwo;

    ret = Qnil;
    rwo = rxml_textwriter_get(self);
    switch (rwo->output_type) {
        case RXMLW_OUTPUT_DOC:
            ret = rwo->output;
            break;
        case RXMLW_OUTPUT_STRING:
            ret = rxml_writer_c_to_ruby_string(rwo->buffer->content, rwo->buffer->use);
            break;
        case RXMLW_OUTPUT_IO:
        case RXMLW_OUTPUT_NONE:
            break;
        default:
            rb_bug("unexpected output");
            break;
    }

    return ret;
}

#set_indent(indentation) ⇒ Object

Toggles indentation on or off. Returns false on failure.

Availability: libxml2 >= 2.6.5



378
379
380
381
382
383
384
385
386
387
 
# File 'ext/libxml/ruby_xml_writer.c', line 378

static VALUE rxml_writer_set_indent(VALUE self, VALUE indentation)
{
    int ret;
    rxml_writer_object *rwo;

    rwo = rxml_textwriter_get(self);
    ret = xmlTextWriterSetIndent(rwo->writer, RTEST(indentation));

    return (-1 == ret ? Qfalse : Qtrue);
}

#set_indent_string(string) ⇒ Object

Sets the string to use to indent each element of the document. Don’t forget to enable indentation with set_indent. Returns false on failure.

Availability: libxml2 >= 2.6.5



398
399
400
401
 
# File 'ext/libxml/ruby_xml_writer.c', line 398

static VALUE rxml_writer_set_indent_string(VALUE self, VALUE indentation)
{
    return numeric_rxml_writer_string(self, indentation, xmlTextWriterSetIndentString);
}

#set_quote_char(...) ⇒ Object

Sets the character used to quote attributes. Returns false on failure.

Notes:

  • only “ (default) and ‘ characters are valid

  • availability: libxml2 >= 2.9.0



985
986
987
988
989
990
991
992
993
994
995
996
 
# File 'ext/libxml/ruby_xml_writer.c', line 985

static VALUE rxml_writer_set_quote_char(VALUE self, VALUE quotechar)
{
    int ret;
    const char *xquotechar;
    rxml_writer_object *rwo;

    rwo = rxml_textwriter_get(self);
    xquotechar = StringValueCStr(quotechar);
    ret = xmlTextWriterSetQuoteChar(rwo->writer, (xmlChar) xquotechar[0]);

    return (-1 == ret ? Qfalse : Qtrue);
}

#start_attribute(name) ⇒ Object

Starts an attribute. Returns false on failure.



566
567
568
569
 
# File 'ext/libxml/ruby_xml_writer.c', line 566

static VALUE rxml_writer_start_attribute(VALUE self, VALUE name)
{
    return numeric_rxml_writer_string(self, name, xmlTextWriterStartAttribute);
}

#start_attribute_ns(prefix, name, namespaceURI) ⇒ Object

Starts a namespaced attribute. Returns false on failure.

Note: by default, the xmlns: definition is repeated on every element. If you want the prefix, but don’t want the xmlns: declaration repeated, set namespaceURI to nil or omit it. Don’t forget to declare the namespace prefix somewhere earlier.



581
582
583
584
585
586
587
588
 
# File 'ext/libxml/ruby_xml_writer.c', line 581

static VALUE rxml_writer_start_attribute_ns(int argc, VALUE *argv, VALUE self)
{
    VALUE prefix, name, namespaceURI;

    rb_scan_args(argc, argv, "21", &prefix, &name, &namespaceURI);

    return numeric_rxml_writer_va_strings(self, Qnil, 3, xmlTextWriterStartAttributeNS, prefix, name, namespaceURI);
}

#start_cdata ⇒ Object

Starts a new CDATA section. Returns false on failure.



680
681
682
683
 
# File 'ext/libxml/ruby_xml_writer.c', line 680

static VALUE rxml_writer_start_cdata(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterStartCDATA);
}

#start_comment ⇒ Object

Starts a comment. Returns false on failure. Note: libxml2 >= 2.6.7 required



607
608
609
610
 
# File 'ext/libxml/ruby_xml_writer.c', line 607

static VALUE rxml_writer_start_comment(VALUE self)
{
    return numeric_rxml_writer_void(self, xmlTextWriterStartComment);
}

#start_document ⇒ Object #start_document(: encoding) ⇒ XML::Encoding::UTF_8

Starts a new document. Returns false on failure.

You may provide an optional hash table to control XML header that will be generated. Valid options are:

  • encoding: the output document encoding, defaults to nil (= UTF-8). Valid

values are the encoding constants defined on XML::Encoding

  • standalone: nil (default) or a boolean to indicate if the document is

standalone or not

Overloads:



709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
 
# File 'ext/libxml/ruby_xml_writer.c', line 709

static VALUE rxml_writer_start_document(int argc, VALUE *argv, VALUE self)
{
    int ret;
    VALUE options;
    rxml_writer_object *rwo;
    const char *xencoding, *xstandalone;

    options = Qnil;
    xstandalone = xencoding = NULL;
    rb_scan_args(argc, argv, "01", &options);
    if (!NIL_P(options)) {
        VALUE encoding, standalone;

        encoding = standalone = Qnil;
        Check_Type(options, T_HASH);
        encoding = rb_hash_aref(options, sEncoding);
        xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
        standalone = rb_hash_aref(options, sStandalone);
        if (NIL_P(standalone)) {
            xstandalone = NULL;
        } else {
            xstandalone = RTEST(standalone) ? "yes" : "no";
        }
    }
    rwo = rxml_textwriter_get(self);
    ret = xmlTextWriterStartDocument(rwo->writer, NULL, xencoding, xstandalone);

    return (-1 == ret ? Qfalse : Qtrue);
}

#start_dtd(qualifiedName, publicId, systemId) ⇒ Object

Starts a DTD. Returns false on failure.



774
775
776
777
778
779
780
781
 
# File 'ext/libxml/ruby_xml_writer.c', line 774

static VALUE rxml_writer_start_dtd(int argc, VALUE *argv, VALUE self)
{
    VALUE name, pubid, sysid;

    rb_scan_args(argc, argv, "12", &name, &pubid, &sysid);

    return numeric_rxml_writer_va_strings(self, Qnil, 3, xmlTextWriterStartDTD, name, pubid, sysid);
}

#start_dtd_attlist(name) ⇒ Object

Starts a DTD attribute list (<!ATTLIST … >). Returns false on failure.



815
816
817
818
 
# File 'ext/libxml/ruby_xml_writer.c', line 815

static VALUE rxml_writer_start_dtd_attlist(VALUE self, VALUE name)
{
    return numeric_rxml_writer_string(self, name, xmlTextWriterStartDTDAttlist);
}

#start_dtd_element(qualifiedName) ⇒ Object

Starts a DTD element (<!ELEMENT … >). Returns false on failure.



788
789
790
791
 
# File 'ext/libxml/ruby_xml_writer.c', line 788

static VALUE rxml_writer_start_dtd_element(VALUE self, VALUE name)
{
    return numeric_rxml_writer_string(self, name, xmlTextWriterStartDTDElement);
}

#start_dtd_entity(name, pe = false) ⇒ Object

Starts a DTD entity (<!ENTITY … >). Returns false on failure.



798
799
800
801
802
803
804
805
806
807
808
 
# File 'ext/libxml/ruby_xml_writer.c', line 798

static VALUE rxml_writer_start_dtd_entity(int argc, VALUE *argv, VALUE self)
{
    VALUE name, pe;

    rb_scan_args(argc, argv, "11", &name, &pe);
    if (NIL_P(pe)) {
        pe = Qfalse;
    }

    return numeric_rxml_writer_va_strings(self, pe, 1, xmlTextWriterStartDTDEntity, name);
}

#start_element(name) ⇒ Object

Starts a new element. Returns false on failure.



629
630
631
632
 
# File 'ext/libxml/ruby_xml_writer.c', line 629

static VALUE rxml_writer_start_element(VALUE self, VALUE name)
{
    return numeric_rxml_writer_string(self, name, xmlTextWriterStartElement);
}

#start_element_ns(prefix, name, namespaceURI) ⇒ Object

Starts a new namespaced element. Returns false on failure.

Note: by default, the xmlns: definition is repeated on every element. If you want the prefix, but don’t want the xmlns: declaration repeated, set namespaceURI to nil or omit it. Don’t forget to declare the namespace prefix somewhere earlier.



644
645
646
647
648
649
650
651
 
# File 'ext/libxml/ruby_xml_writer.c', line 644

static VALUE rxml_writer_start_element_ns(int argc, VALUE *argv, VALUE self)
{
    VALUE prefix, name, namespaceURI;

    rb_scan_args(argc, argv, "21", &prefix, &name, &namespaceURI);

    return numeric_rxml_writer_va_strings(self, Qnil, 3, xmlTextWriterStartElementNS, prefix, name, namespaceURI);
}

#start_pi(target) ⇒ Object

Starts a new processing instruction. Returns false on failure.



754
755
756
757
 
# File 'ext/libxml/ruby_xml_writer.c', line 754

static VALUE rxml_writer_start_pi(VALUE self, VALUE target)
{
    return numeric_rxml_writer_string(self, target, xmlTextWriterStartPI);
}

#write_attribute(name, content) ⇒ Object

Writes a full attribute, all at once. Returns false on failure. Same as start_attribute(name) + write_string(content) + end_attribute.



496
497
498
499
 
# File 'ext/libxml/ruby_xml_writer.c', line 496

static VALUE rxml_writer_write_attribute(VALUE self, VALUE name, VALUE content)
{
    return numeric_rxml_writer_va_strings(self, Qnil, 2, xmlTextWriterWriteAttribute, name, content);
}

#write_attribute_ns(prefix, name, namespaceURI, content) ⇒ Object

Writes a full namespaced attribute, all at once. Returns false on failure. Same as start_attribute_ns(prefix, name, namespaceURI) + write_string(content) + end_attribute.

Notes:

  • by default, the xmlns: definition is repeated on every element. If you want

the prefix, but don’t want the xmlns: declaration repeated, set namespaceURI to nil or omit it. Don’t forget to declare the namespace prefix somewhere earlier.

  • content can be omitted too for an empty attribute



515
516
517
518
519
520
521
522
 
# File 'ext/libxml/ruby_xml_writer.c', line 515

static VALUE rxml_writer_write_attribute_ns(int argc, VALUE *argv, VALUE self)
{
    VALUE prefix, name, namespaceURI, content;

    rb_scan_args(argc, argv, "22", &prefix, &name, &namespaceURI, &content);

    return numeric_rxml_writer_va_strings(self, Qnil, 4, xmlTextWriterWriteAttributeNS, prefix, name, namespaceURI, content);
}

#write_cdata(content) ⇒ Object

Writes a full CDATA section, all at once. Returns false on failure. This is equivalent to start_cdata + write_string(content) + end_cdata.



425
426
427
428
 
# File 'ext/libxml/ruby_xml_writer.c', line 425

static VALUE rxml_writer_write_cdata(VALUE self, VALUE content)
{
    return numeric_rxml_writer_string(self, content, xmlTextWriterWriteCDATA);
}

#write_comment(content) ⇒ Object

Writes a full comment tag, all at once. Returns false on failure. This is equivalent to start_comment + write_string(content) + end_comment.



414
415
416
417
 
# File 'ext/libxml/ruby_xml_writer.c', line 414

static VALUE rxml_writer_write_comment(VALUE self, VALUE content)
{
    return numeric_rxml_writer_string(self, content, xmlTextWriterWriteComment);
}

#write_dtd(name[ [ [, publicId ], systemId ], subset ]) ⇒ Object

Writes a DTD, all at once. Returns false on failure.

  • name: dtd name

  • publicId: external subset public identifier, use nil for a SYSTEM doctype

  • systemId: external subset system identifier

  • subset: content

Examples:

writer.write_dtd 'html'
  # => <!DOCTYPE html>
writer.write_dtd 'docbook', nil, 'http://www.docbook.org/xml/5.0/dtd/docbook.dtd'
  # => <!DOCTYPE docbook SYSTEM "http://www.docbook.org/xml/5.0/dtd/docbook.dtd">
writer.write_dtd 'html', '-//W3C//DTD XHTML 1.1//EN', 'http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd'
  # => <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
writer.write_dtd 'person', nil, nil, '<!ELEMENT person (firstname,lastname)><!ELEMENT firstname (#PCDATA)><!ELEMENT lastname (#PCDATA)>'
  # => <!DOCTYPE person [<!ELEMENT person (firstname,lastname)><!ELEMENT firstname (#PCDATA)><!ELEMENT lastname (#PCDATA)>]>



879
880
881
882
883
884
885
886
 
# File 'ext/libxml/ruby_xml_writer.c', line 879

static VALUE rxml_writer_write_dtd(int argc, VALUE *argv, VALUE self)
{
    VALUE name, pubid, sysid, subset;

    rb_scan_args(argc, argv, "13", &name, &pubid, &sysid, &subset);

    return numeric_rxml_writer_va_strings(self, Qnil, 4, xmlTextWriterWriteDTD, name, pubid, sysid, subset);
}

#write_dtd_attlist(name, content) ⇒ Object

Writes a DTD attribute list, all at once. Returns false on failure.

writer.write_dtd_attlist 'id', 'ID #IMPLIED'
  # => <!ATTLIST id ID #IMPLIED>



895
896
897
898
 
# File 'ext/libxml/ruby_xml_writer.c', line 895

static VALUE rxml_writer_write_dtd_attlist(VALUE self, VALUE name, VALUE content)
{
    return numeric_rxml_writer_va_strings(self, Qnil, 2, xmlTextWriterWriteDTDAttlist, name, content);
}

#write_dtd_element(name, content) ⇒ Object

Writes a full DTD element, all at once. Returns false on failure.

writer.write_dtd_element 'person', '(firstname,lastname)'
  # => <!ELEMENT person (firstname,lastname)>



907
908
909
910
 
# File 'ext/libxml/ruby_xml_writer.c', line 907

static VALUE rxml_writer_write_dtd_element(VALUE self, VALUE name, VALUE content)
{
    return numeric_rxml_writer_va_strings(self, Qnil, 2, xmlTextWriterWriteDTDElement, name, content);
}

#write_dtd_entity(name, publicId, systemId, ndataid, content, pe) ⇒ Object

Writes a DTD entity, all at once. Returns false on failure.



917
918
919
920
 
# File 'ext/libxml/ruby_xml_writer.c', line 917

static VALUE rxml_writer_write_dtd_entity(VALUE self, VALUE name, VALUE pubid, VALUE sysid, VALUE ndataid, VALUE content, VALUE pe)
{
    return numeric_rxml_writer_va_strings(self, pe, 5, xmlTextWriterWriteDTDEntity, name, pubid, sysid, ndataid, content);
}

#write_dtd_external_entity(name, publicId, systemId, ndataid, pe) ⇒ Object

Writes a DTD external entity. The entity must have been started with start_dtd_entity. Returns false on failure.

  • name: the name of the DTD entity

  • publicId: the public identifier, which is an alternative to the system identifier

  • systemId: the system identifier, which is the URI of the DTD

  • ndataid: the xml notation name

  • pe: true if this is a parameter entity (to be used only in the DTD

itself), false if not



934
935
936
937
 
# File 'ext/libxml/ruby_xml_writer.c', line 934

static VALUE rxml_writer_write_dtd_external_entity(VALUE self, VALUE name, VALUE pubid, VALUE sysid, VALUE ndataid, VALUE pe)
{
    return numeric_rxml_writer_va_strings(self, pe, 4, xmlTextWriterWriteDTDExternalEntity, name, pubid, sysid, ndataid);
}

#write_dtd_external_entity_contents(publicId, systemId, ndataid) ⇒ Object

Writes the contents of a DTD external entity, all at once. Returns false on failure.



944
945
946
947
 
# File 'ext/libxml/ruby_xml_writer.c', line 944

static VALUE rxml_writer_write_dtd_external_entity_contents(VALUE self, VALUE pubid, VALUE sysid, VALUE ndataid)
{
    return numeric_rxml_writer_va_strings(self, Qnil, 3, xmlTextWriterWriteDTDExternalEntityContents, pubid, sysid, ndataid);
}

#write_dtd_internal_entity(name, content, pe) ⇒ Object

Writes a DTD internal entity, all at once. Returns false on failure.

Examples:

writer.write_dtd_entity 'Shape', '(rect|circle|poly|default)', true
  # => <!ENTITY % Shape "(rect|circle|poly|default)">
writer.write_dtd_entity 'delta', '&#948;', false
  # => <!ENTITY delta "&#948;">



960
961
962
963
 
# File 'ext/libxml/ruby_xml_writer.c', line 960

static VALUE rxml_writer_write_dtd_internal_entity(VALUE self, VALUE name, VALUE content, VALUE pe)
{
    return numeric_rxml_writer_va_strings(self, pe, 2, xmlTextWriterWriteDTDInternalEntity, name, content);
}

#write_dtd_notation(name, publicId, systemId) ⇒ Object

Writes a DTD entity, all at once. Returns false on failure.



970
971
972
973
 
# File 'ext/libxml/ruby_xml_writer.c', line 970

static VALUE rxml_writer_write_dtd_notation(VALUE self, VALUE name, VALUE pubid, VALUE sysid)
{
    return numeric_rxml_writer_va_strings(self, Qnil, 3, xmlTextWriterWriteDTDNotation, name, pubid, sysid);
}

#write_element(name, content) ⇒ Object

Writes a full element tag, all at once. Returns false on failure. This is equivalent to start_element(name) + write_string(content) + end_element.



441
442
443
444
445
446
447
448
449
450
451
452
453
454
 
# File 'ext/libxml/ruby_xml_writer.c', line 441

static VALUE rxml_writer_write_element(int argc, VALUE *argv, VALUE self)
{
    VALUE name, content;

    rb_scan_args(argc, argv, "11", &name, &content);
    if (Qnil == content) {
        if (Qfalse == rxml_writer_start_element(self, name)) {
            return Qfalse;
        }
        return rxml_writer_end_element(self);
    } else {
        return numeric_rxml_writer_va_strings(self, Qnil, 2, xmlTextWriterWriteElement, name, content);
    }
}

#write_element_ns(prefix, name, namespaceURI, content) ⇒ Object

Writes a full namespaced element tag, all at once. Returns false on failure. This is a shortcut for start_element_ns(prefix, name, namespaceURI) + write_string(content) + end_element.

Notes:

  • by default, the xmlns: definition is repeated on every element. If you want

the prefix, but don’t want the xmlns: declaration repeated, set namespaceURI to nil or omit it. Don’t forget to declare the namespace prefix somewhere earlier.

  • content can be omitted for an empty tag



473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
 
# File 'ext/libxml/ruby_xml_writer.c', line 473

static VALUE rxml_writer_write_element_ns(int argc, VALUE *argv, VALUE self)
{
    VALUE prefix, name, namespaceURI, content;

    rb_scan_args(argc, argv, "22", &prefix, &name, &namespaceURI, &content);
    if (Qnil == content) {
        VALUE argv[3] = { prefix, name, namespaceURI };

        if (Qfalse == rxml_writer_start_element_ns(ARRAY_SIZE(argv), argv, self)) {
            return Qfalse;
        }
        return rxml_writer_end_element(self);
    } else {
        return numeric_rxml_writer_va_strings(self, Qnil, 4, xmlTextWriterWriteElementNS, prefix, name, namespaceURI, content);
    }
}

#write_pi(target, content) ⇒ Object

Writes a full CDATA tag, all at once. Returns false on failure. This is a shortcut for start_pi(target) + write_string(content) + end_pi.



530
531
532
533
 
# File 'ext/libxml/ruby_xml_writer.c', line 530

static VALUE rxml_writer_write_pi(VALUE self, VALUE target, VALUE content)
{
    return numeric_rxml_writer_va_strings(self, Qnil, 2, xmlTextWriterWritePI, target, content);
}

#write_raw(content) ⇒ Object

Writes the string content as is, reserved characters are not translated to their associated entities. Returns false on failure. Consider write_string to handle them.



556
557
558
559
 
# File 'ext/libxml/ruby_xml_writer.c', line 556

static VALUE rxml_writer_write_raw(VALUE self, VALUE content)
{
    return numeric_rxml_writer_string(self, content, xmlTextWriterWriteRaw);
}

#write_string(content) ⇒ Object

Safely (problematic characters are internally translated to their associated named entities) writes a string into the current node (attribute, element, comment, …). Returns false on failure.



544
545
546
547
 
# File 'ext/libxml/ruby_xml_writer.c', line 544

static VALUE rxml_writer_write_string(VALUE self, VALUE content)
{
    return numeric_rxml_writer_string(self, content, xmlTextWriterWriteString);
}