Class: LibXML::XML::Namespaces

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
ext/libxml/ruby_xml_namespaces.c,
lib/libxml/namespaces.rb,
ext/libxml/ruby_xml_namespaces.c

Overview

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.

Instance Method Summary collapse

Constructor Details

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



62
63
64
65
66
67
68
69
70
 
# File 'ext/libxml/ruby_xml_namespaces.c', line 62

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

  TypedData_Get_Struct(node, xmlNode, &rxml_node_data_type, xnode);

  RTYPEDDATA_DATA(self) = xnode;
  return self;
}

Instance Method Details

#default ⇒ Object

call-seq:

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



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

def default
  find_by_prefix(nil)
end

#default_prefix=(prefix) ⇒ Object

call-seq:

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

Raises:

  • (ArgumentError) 


30
31
32
33
34
35
 
# 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

#definitions ⇒ Array, 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

Returns ].

Returns:



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'ext/libxml/ruby_xml_namespaces.c', line 84

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

  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, 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 ⇒ Object 



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

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

  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);

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

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

  rb_ensure(rxml_namespaces_each_yield, (VALUE)nsList,
            rxml_namespaces_free_list, (VALUE)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 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)

Returns:



175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'ext/libxml/ruby_xml_namespaces.c', line 175

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

  Check_Type(href, T_STRING);
  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, 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 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)

Returns:



207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'ext/libxml/ruby_xml_namespaces.c', line 207

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

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

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

Returns:



242
243
244
245
246
247
248
249
250
251
 
# File 'ext/libxml/ruby_xml_namespaces.c', line 242

static VALUE rxml_namespaces_namespace_get(VALUE self)
{
  xmlNodePtr xnode;
  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);

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

#namespace=(XML) ⇒ Object

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)



272
273
274
275
276
277
278
279
280
281
282
283
 
# File 'ext/libxml/ruby_xml_namespaces.c', line 272

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

  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);

  TypedData_Get_Struct(ns, xmlNs, &rxml_namespace_type, xns);

  xmlSetNs(xnode, xns);
  return self;
}

#node ⇒ XML::Node

Returns the current node.

Returns:



291
292
293
294
295
296
 
# File 'ext/libxml/ruby_xml_namespaces.c', line 291

static VALUE rxml_namespaces_node_get(VALUE self)
{
  xmlNodePtr xnode;
  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);
  return rxml_node_wrap(xnode);
}