class LibXML::XML::Namespaces

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.

Public Class Methods

initialize(XML::Node) → XML::Namespaces click to toggle source

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)

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

default → XML::Namespace click to toggle source

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/')

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

default_prefix = "string" click to toggle source

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')

   # File lib/libxml/namespaces.rb
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

definitions → [XML::Namespace, XML::Namespace] click to toggle source

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

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);
    rb_ary_push(arr, anamespace);
    xns = xns->next;
  }

  return arr;
}

each {|XML::Namespace|} click to toggle source

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

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);
    rb_yield(ns);
  }
  xmlFree(nsList);

  return Qnil;
}

find_by_href(href) → XML::Namespace click to toggle source

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)

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);
  else
    return Qnil;
}

find_by_prefix(prefix=nil) → XML::Namespace click to toggle source

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)

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);
  else
    return Qnil;
}

namespace → XML::Namespace click to toggle source

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)

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);
  else
    return Qnil;
}

namespace = XML::Namespace click to toggle source

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)

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;
}

node → XML::Node click to toggle source

Returns the current node.

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