class Nokogiri::XML::Attr - nokogiri-1.18.10 Documentation

# class Nokogiri::XML::Attr

`Attr` represents a `Attr` node in an xml document.

### Public Class Methods

new(document, name) click to toggle source

Create a new `Attr` element on the `document` with `name`

    static VALUE
    new (int argc, VALUE *argv, VALUE klass)
    {
      xmlDocPtr xml_doc;
      VALUE document;
      VALUE name;
      VALUE rest;
      xmlAttrPtr node;
      VALUE rb_node;

      rb_scan_args(argc, argv, "2*", &document, &name, &rest);

      if (! rb_obj_is_kind_of(document, cNokogiriXmlDocument)) {
        rb_raise(rb_eArgError, "parameter must be a Nokogiri::XML::Document");
      }

      xml_doc = noko_xml_document_unwrap(document);

      node = xmlNewDocProp(
               xml_doc,
               (const xmlChar *)StringValueCStr(name),
               NULL
             );

      noko_xml_document_pin_node((xmlNodePtr)node);

      rb_node = noko_xml_node_wrap(klass, (xmlNodePtr)node);
      rb_obj_call_init(rb_node, argc, argv);

      if (rb_block_given_p()) {
        rb_yield(rb_node);
      }

      return rb_node;
    }

### Public Instance Methods

content=
Alias for: value=
deconstruct_keys(array_of_names) → Hash click to toggle source

Returns a hash describing the `Attr`, to use in pattern matching.

Valid keys and their values:

- `name` → (String) The name of the attribute.

- `value` → (String) The value of the attribute.

- `namespace` → (`Namespace`, nil) The `Namespace` of the attribute, or `nil` if there is no namespace.

Example

    doc = Nokogiri::XML.parse(<<~XML)
      <?xml version="1.0"?>
      <root xmlns="http://nokogiri.org/ns/default" xmlns:noko="http://nokogiri.org/ns/noko">
        <child1 foo="abc" noko:bar="def"/>
      </root>
    XML

    attributes = doc.root.elements.first.attribute_nodes
    # => [#(Attr:0x35c { name = "foo", value = "abc" }),
    #     #(Attr:0x370 {
    #       name = "bar",
    #       namespace = #(Namespace:0x384 {
    #         prefix = "noko",
    #         href = "http://nokogiri.org/ns/noko"
    #         }),
    #       value = "def"
    #       })]

    attributes.first.deconstruct_keys([:name, :value, :namespace])
    # => {:name=>"foo", :value=>"abc", :namespace=>nil}

    attributes.last.deconstruct_keys([:name, :value, :namespace])
    # => {:name=>"bar",
    #     :value=>"def",
    #     :namespace=>
    #      #(Namespace:0x384 {
    #        prefix = "noko",
    #        href = "http://nokogiri.org/ns/noko"
    #        })}

Since v1.14.0

    # File lib/nokogiri/xml/attr.rb, line 55
    def deconstruct_keys(keys)
      { name: name, value: value, namespace: namespace }
    end

value=(content) click to toggle source

Set the value for this `Attr` to `content`. Use `nil` to remove the value (e.g., a `HTML` boolean attribute).

    static VALUE
    set_value(VALUE self, VALUE content)
    {
      xmlAttrPtr attr;
      xmlChar *value;
      xmlNode *cur;

      Noko_Node_Get_Struct(self, xmlAttr, attr);

      if (attr->children) {
        xmlFreeNodeList(attr->children);
      }
      attr->children = attr->last = NULL;

      if (content == Qnil) {
        return content;
      }

      value = xmlEncodeEntitiesReentrant(attr->doc, (unsigned char *)StringValueCStr(content));
      if (xmlStrlen(value) == 0) {
        attr->children = xmlNewDocText(attr->doc, value);
      } else {
        attr->children = xmlStringGetNodeList(attr->doc, value);
      }
      xmlFree(value);

      for (cur = attr->children; cur; cur = cur->next) {
        cur->parent = (xmlNode *)attr;
        cur->doc = attr->doc;
        if (cur->next == NULL) {
          attr->last = cur;
        }
      }

      return content;
    }

Also aliased as: content=

### Private Instance Methods

inspect_attributes() click to toggle source

    # File lib/nokogiri/xml/attr.rb, line 61
    def inspect_attributes
      [:name, :namespace, :value]
    end