: LibXML::XML::Namespaces [LibXML]

The XML::Namespaces class is used to access information about a node’s namespaces. For each node, libxml maintains:

The node’s namespace (namespace)
Which namespaces are defined on the node (definnitions)
Which namespaces are in scope for the node (each)

Let’s look at an example:

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
               xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <soap:Body>
    <order xmlns="http://mynamespace.com"/>
  </soap:Body>
</soap>

The Envelope node is in the soap namespace. It contains two namespace definitions, one for soap and one for xsd.

The Body node is also in the soap namespace and does not contain any namespaces. However, the soap and xsd namespaces are both in context.

The order node is in its default namespace and contains one namespace definition (mynamespace.com). There are three namespaces in context soap, xsd and the default namespace.

Methods

public class

initialize

Included modules

Enumerable

Public class methods

initialize(XML::Node) → XML::Namespaces

Creates a new namespaces object. Generally you do not call this method directly, but instead access a namespaces object via XML::Node#namespaces.

Usage:

doc = XML::Document.string('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"/>')
namespaces = new XML::Namespaces(doc.root)

[show source]

static VALUE rxml_namespaces_initialize(VALUE self, VALUE node)
{
  xmlNodePtr xnode;

  Check_Type(node, T_DATA);
  Data_Get_Struct(node, xmlNode, xnode);

  DATA_PTR(self) = xnode;
  return self;
}

Public instance methods

namespace.default → XML::Namespace

Returns the default namespace for this node or nil.

Usage:

doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
ns = doc.root.namespaces.default_namespace
assert_equal(ns.href, 'http://schemas.xmlsoap.org/soap/envelope/')

[show source]

    # File lib/libxml/namespaces.rb, line 15
15:       def default
16:         find_by_prefix(nil)
17:       end

namespace.default_prefix = "string"

Assigns a name (prefix) to the default namespace. This makes it much easier to perform XML::XPath searches.

Usage:

doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
doc.root.namespaces.default_prefix = 'soap'
node = doc.root.find_first('soap:Envelope')

[show source]

    # File lib/libxml/namespaces.rb, line 30
30:       def default_prefix=(prefix)
31:         # Find default prefix
32:         ns = find_by_prefix(nil)
33:         raise(ArgumentError, "No default namespace was found") unless ns
34:         Namespace.new(self.node, prefix, ns.href)
35:       end

namespaces.definitions → [XML::Namespace, XML::Namespace]

Returns an array of XML::Namespace objects that are defined on this node.

Usage:

doc = XML::Document.string('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"/>')
defs = doc.root.namespaces.definitions

[show source]

static VALUE rxml_namespaces_definitions(VALUE self)
{
  xmlNodePtr xnode;
  xmlNsPtr xns;
  VALUE arr;

  Data_Get_Struct(self, xmlNode, xnode);

  arr = rb_ary_new();
  xns = xnode->nsDef;

  while (xns)
  {
    VALUE anamespace = rxml_namespace_wrap(xns, NULL);
    rb_ary_push(arr, anamespace);
    xns = xns->next;
  }

  return arr;
}

namespaces.each {|XML::Namespace|}

Iterates over the namespace objects that are in context for this node.

Usage:

doc = XML::Document.string('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"/>')
doc.root.namespaces.each do |ns|
  ..
end

[show source]

static VALUE rxml_namespaces_each(VALUE self)
{
  xmlNodePtr xnode;
  xmlNsPtr *nsList, *xns;

  Data_Get_Struct(self, xmlNode, xnode);

  nsList = xmlGetNsList(xnode->doc, xnode);

  if (nsList == NULL)
    return (Qnil);

  for (xns = nsList; *xns != NULL; xns++)
  {
    VALUE ns = rxml_namespace_wrap(*xns, NULL);
    rb_yield(ns);
  }
  xmlFree(nsList);

  return Qnil;
}

namespaces.find_by_href(href) → XML::Namespace

Searches for a namespace that has the specified href. The search starts at the current node and works upward through the node’s parents. If a namespace is found, then an XML::Namespace instance is returned, otherwise nil is returned.

Usage:

doc = XML::Document.string('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"/>')
ns = doc.root.namespaces.find_by_href('http://schemas.xmlsoap.org/soap/envelope/')
assert_equal('soap', ns.prefix)
assert_equal('http://schemas.xmlsoap.org/soap/envelope/', ns.href)

[show source]

static VALUE rxml_namespaces_find_by_href(VALUE self, VALUE href)
{
  xmlNodePtr xnode;
  xmlNsPtr xns;

  Check_Type(href, T_STRING);
  Data_Get_Struct(self, xmlNode, xnode);

  xns = xmlSearchNsByHref(xnode->doc, xnode, (xmlChar*) StringValuePtr(href));
  if (xns)
    return rxml_namespace_wrap(xns, NULL);
  else
    return Qnil;
}

namespaces.find_by_prefix(prefix=nil) → XML::Namespace

Searches for a namespace that has the specified prefix. The search starts at the current node and works upward through the node’s parents. If a namespace is found, then an XML::Namespace instance is returned, otherwise nil is returned.

Usage:

doc = XML::Document.string('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"/>')
ns = doc.root.namespaces.find_by_prefix('soap')
assert_equal('soap', ns.prefix)
assert_equal('http://schemas.xmlsoap.org/soap/envelope/', ns.href)

[show source]

static VALUE rxml_namespaces_find_by_prefix(VALUE self, VALUE prefix)
{
  xmlNodePtr xnode;
  xmlNsPtr xns;
  xmlChar* xprefix = NULL;

  
  if (!NIL_P(prefix))
  {
    Check_Type(prefix, T_STRING);
    xprefix = (xmlChar*) StringValuePtr(prefix);
  }

  Data_Get_Struct(self, xmlNode, xnode);
  
  xns = xmlSearchNs(xnode->doc, xnode, xprefix);
  if (xns)
    return rxml_namespace_wrap(xns, NULL);
  else
    return Qnil;
}

namespaces.namespace → XML::Namespace

Returns the current node’s namespace.

Usage:

doc = XML::Document.string('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"/>')
ns = doc.root.namespaces.namespace
assert_equal('soap', ns.prefix)
assert_equal('http://schemas.xmlsoap.org/soap/envelope/', ns.href)

[show source]

static VALUE rxml_namespaces_namespace_get(VALUE self)
{
  xmlNodePtr xnode;
  Data_Get_Struct(self, xmlNode, xnode);

  if (xnode->ns)
    return rxml_namespace_wrap(xnode->ns, NULL);
  else
    return Qnil;
}

namespaces.namespace = XML::Namespace

Sets the current node’s namespace.

Basic usage:

# Create a node
node = XML::Node.new('Envelope')

# Define the soap namespace - this does *not* put the node in the namespace
ns = XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)

# Now put the node in the soap namespace, not how the string representation changes
node.namespaces.namespace = ns
assert_equal("<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)

[show source]

static VALUE rxml_namespaces_namespace_set(VALUE self, VALUE ns)
{
  xmlNodePtr xnode;
  xmlNsPtr xns;

  Data_Get_Struct(self, xmlNode, xnode);

  Check_Type(ns, T_DATA);
  Data_Get_Struct(ns, xmlNs, xns);

  xmlSetNs(xnode, xns);
  return self;
}

namespaces.node → XML::Node

Returns the current node.

[show source]

static VALUE rxml_namespaces_node_get(VALUE self)
{
  xmlNodePtr xnode;
  Data_Get_Struct(self, xmlNode, xnode);
  return rxml_node_wrap(xnode);
}

Class LibXML::XML::Namespaces

Methods

public class

public instance

Included modules

Public class methods

Public instance methods