Class: LibXML::XML::Namespaces

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Instance Chain: self, Enumerable
Inherits:	Object
Defined in:	ext/libxml/ruby_xml_namespaces.c, ext/libxml/ruby_xml_namespaces.c, lib/libxml/namespaces.rb

Overview

The 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.

Class Method Summary

.new(XML::Node) ⇒ Namespaces constructor

Creates a new namespaces object.

Instance Attribute Summary

#default_prefix=("string") writeonly

Assigns a name (prefix) to the default namespace.
#namespace ⇒ XML::Namespace rw

Returns the current node’s namespace.
#namespace=(XML::Namespace) rw

Sets the current node’s namespace.

Instance Method Summary

#default ⇒ XML::Namespace

Returns the default namespace for this node or nil.
#definitions ⇒ Array, XML::Namespace

Returns an array of Namespace objects that are defined on this node.
#each {|XML::Namespace| ... }

Iterates over the namespace objects that are in context for this node.
#find_by_href(href) ⇒ XML::Namespace

Searches for a namespace that has the specified href.
#find_by_prefix(prefix = nil) ⇒ XML::Namespace

Searches for a namespace that has the specified prefix.
#node ⇒ XML::Node

Returns the current node.

Constructor Details

.new(XML::Node) ⇒ `Namespaces`

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

Usage:

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

[ GitHub ]

# File 'ext/libxml/ruby_xml_namespaces.c', line 57


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

Instance Attribute Details

#default_prefix=("string") (writeonly)

Assigns a name (prefix) to the default namespace. This makes it much easier to perform 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')

Raises:

(ArgumentError)

[ GitHub ]

# File 'lib/libxml/namespaces.rb', line 30


def default_prefix=(prefix)
  # Find default prefix
  ns = find_by_prefix(nil)
  raise(ArgumentError, "No default namespace was found") unless ns
  Namespace.new(self.node, prefix, ns.href)
end

#namespace ⇒ XML::Namespace (rw)

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)

[ GitHub ]

# File 'ext/libxml/ruby_xml_namespaces.c', line 221


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) (rw)

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)

[ GitHub ]

# File 'ext/libxml/ruby_xml_namespaces.c', line 251


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

Instance Method Details

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

[ GitHub ]

# File 'lib/libxml/namespaces.rb', line 15


def default
  find_by_prefix(nil)
end

#definitions ⇒ `Array`, XML::Namespace

Returns an array of 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

[ GitHub ]

# File 'ext/libxml/ruby_xml_namespaces.c', line 80


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

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

[ GitHub ]

# File 'ext/libxml/ruby_xml_namespaces.c', line 115


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

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

[ GitHub ]

# File 'ext/libxml/ruby_xml_namespaces.c', line 154


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

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

[ GitHub ]

# File 'ext/libxml/ruby_xml_namespaces.c', line 186


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

#node ⇒ XML::Node

Returns the current node.

[ GitHub ]

# File 'ext/libxml/ruby_xml_namespaces.c', line 271


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

Overview

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(XML::Node) ⇒ Namespaces

Instance Attribute Details

#default_prefix=("string") (writeonly)

#namespace ⇒ XML::Namespace (rw)

#namespace=(XML::Namespace) (rw)

Instance Method Details

#default ⇒ XML::Namespace

#definitions ⇒ Array, XML::Namespace

#each {|XML::Namespace| ... }

#find_by_href(href) ⇒ XML::Namespace

#find_by_prefix(prefix = nil) ⇒ XML::Namespace

#node ⇒ XML::Node

.new(XML::Node) ⇒ `Namespaces`

#definitions ⇒ `Array`, XML::Namespace