class LibXML::XML::Dtd

The XML::Dtd class is used to prepare DTD’s for validation of xml documents.

DTDs can be created from a string or a pair of public and system identifiers. Once a Dtd object is instantiated, an XML document can be validated by the XML::Document#validate method providing the XML::Dtd object as parameeter. The method will raise an exception if the document is not valid.

Basic usage:

# parse DTD
dtd = XML::Dtd.new(<<EOF)
<!ELEMENT root (item*) >
<!ELEMENT item (#PCDATA) >
EOF

# parse xml document to be validated
instance = XML::Document.file('instance.xml')

# validate
instance.validate(dtd)

Public Class Methods

XML::Dtd.new(dtd_string) → dtd click to toggle source

XML::Dtd.new(external_id, system_id) → dtd

XML::Dtd.new(external_id, system_id, name, document, internal) → dtd

Create a new Dtd from the specified public and system identifiers:

* The first usage creates a DTD from a string and requires 1 parameter.
* The second usage loads and parses an external DTD and requires 2 parameters.
* The third usage creates a new internal or external DTD and requires 2 parameters and 3 optional parameters.
  The DTD is then attached to the specified document if it is not nil.

Parameters:

dtd_string - A string that contains a complete DTD
external_id - A string that specifies the DTD's external name. For example, "-//W3C//DTD XHTML 1.0 Transitional//EN"
system_id - A string that specififies the DTD's system name. For example, "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
name - A string that specifies the DTD's name. For example "xhtml1".
document - A xml document.
internal - Boolean value indicating whether this is an internal or external DTD. Optional. If not specified
           then external is assumed.

static VALUE rxml_dtd_initialize(int argc, VALUE *argv, VALUE self)
{
  xmlDtdPtr xdtd;
  VALUE external, system;

  switch (argc)
  {
      case 3:
      case 4:
      case 5:
      {
          const xmlChar *xname = NULL, *xpublic = NULL, *xsystem = NULL;
          xmlDocPtr xdoc = NULL;

          VALUE name, doc, internal;
          rb_scan_args(argc, argv, "23", &external, &system, &name, &doc, &internal);

          Check_Type(external, T_STRING);
          xpublic = (const xmlChar*) StringValuePtr(external);

          Check_Type(system, T_STRING);
          xsystem = (const xmlChar*) StringValuePtr(system);

          if (name != Qnil)
          {
            Check_Type(name, T_STRING);
            xname = (const xmlChar*)StringValuePtr(name);
          }

          if (doc != Qnil)
          {
            if (rb_obj_is_kind_of(doc, cXMLDocument) == Qfalse)
              rb_raise(rb_eTypeError, "Must pass an LibXML::XML::Document object");
            Data_Get_Struct(doc, xmlDoc, xdoc);
          }

          if (internal == Qnil || internal == Qfalse)
            xdtd = xmlNewDtd(xdoc, xname, xpublic, xsystem);
          else
            xdtd = xmlCreateIntSubset(xdoc, xname, xpublic, xsystem);

          if (xdtd == NULL)
            rxml_raise(xmlGetLastError());

          /* The document will free the dtd so Ruby should not */
          RDATA(self)->dfree = NULL;
          DATA_PTR(self) = xdtd;

          xmlSetTreeDoc((xmlNodePtr) xdtd, xdoc);
        }
        break;

      case 2:
      {
        rb_scan_args(argc, argv, "20", &external, &system);

        Check_Type(external, T_STRING);
        Check_Type(system, T_STRING);

        xdtd = xmlParseDTD((xmlChar*) StringValuePtr(external), (xmlChar*) StringValuePtr(system));

        if (xdtd == NULL)
          rxml_raise(xmlGetLastError());

        DATA_PTR(self) = xdtd;

        xmlSetTreeDoc((xmlNodePtr) xdtd, NULL);
        break;
      }
      case 1:
      {
        VALUE dtd_string;
        rb_scan_args(argc, argv, "10", &dtd_string);
        Check_Type(dtd_string, T_STRING);

        /* Note that buffer is freed by xmlParserInputBufferPush*/
        xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
        xmlParserInputBufferPtr buffer = xmlAllocParserInputBuffer(enc);
        xmlChar *new_string = xmlStrdup((xmlChar*) StringValuePtr(dtd_string));
        xmlParserInputBufferPush(buffer, xmlStrlen(new_string),
            (const char*) new_string);

        xdtd = xmlIOParseDTD(NULL, buffer, enc);

        if (xdtd == NULL)
          rxml_raise(xmlGetLastError());

        xmlFree(new_string);

        DATA_PTR(self) = xdtd;
        break;
      }
      default:
        rb_raise(rb_eArgError, "wrong number of arguments");
  }

  return self;
}

Public Instance Methods

external_id → "string" click to toggle source

Obtain this dtd’s external identifer (for a PUBLIC DTD).

static VALUE rxml_dtd_external_id_get(VALUE self)
{
  xmlDtdPtr xdtd;
  Data_Get_Struct(self, xmlDtd, xdtd);


  if (xdtd->ExternalID == NULL)
    return (Qnil);
  else
    return (rxml_new_cstr( xdtd->ExternalID, NULL));
}

name → "string" click to toggle source

Obtain this dtd’s name.

static VALUE rxml_dtd_name_get(VALUE self)
{
  xmlDtdPtr xdtd;
  Data_Get_Struct(self, xmlDtd, xdtd);


  if (xdtd->name == NULL)
    return (Qnil);
  else
    return (rxml_new_cstr( xdtd->name, NULL));
}

type → num click to toggle source

Obtain this node’s type identifier.

static VALUE rxml_dtd_type(VALUE self)
{
  xmlDtdPtr xdtd;
  Data_Get_Struct(self, xmlDtd, xdtd);
  return (INT2NUM(xdtd->type));
}

system_id()

Obtain this dtd’s URI (for a SYSTEM or PUBLIC DTD).

Alias for: uri

uri → "string" click to toggle source

Obtain this dtd’s URI (for a SYSTEM or PUBLIC DTD).

static VALUE rxml_dtd_uri_get(VALUE self)
{
  xmlDtdPtr xdtd;
  Data_Get_Struct(self, xmlDtd, xdtd);

  if (xdtd->SystemID == NULL)
    return (Qnil);
  else
    return (rxml_new_cstr( xdtd->SystemID, NULL));
}

Also aliased as: system_id