Class: Nokogiri::XML::Node

# File 'lib/nokogiri/xml/node.rb', line 126

def initialize(name, document)
  # This is intentionally empty, and sets the method signature for subclasses.
end

# File 'lib/nokogiri/xml/node.rb', line 1171

def cdata?
  type == CDATA_SECTION_NODE
end

# File 'ext/nokogiri/xml_node.c', line 708

static VALUE
rb_xml_node_children(VALUE self)
{
  xmlNodePtr node;
  xmlNodePtr child;
  xmlNodeSetPtr set;
  VALUE document;
  VALUE node_set;

  Noko_Node_Get_Struct(self, xmlNode, node);

  child = node->children;
  set = xmlXPathNodeSetCreate(child);

  document = DOC_RUBY_OBJECT(node->doc);

  if (!child) { return noko_xml_node_set_wrap(set, document); }

  child = child->next;
  while (NULL != child) {
    xmlXPathNodeSetAddUnique(set, child);
    child = child->next;
  }

  node_set = noko_xml_node_set_wrap(set, document);

  return node_set;
}

# File 'lib/nokogiri/xml/node.rb', line 385

def children=(node_or_tags)
  node_or_tags = coerce(node_or_tags)
  children.unlink
  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_child_node_and_reparent_attrs(n) }
  else
    add_child_node_and_reparent_attrs(node_or_tags)
  end
end

# File 'lib/nokogiri/xml/node.rb', line 1166

def comment?
  type == COMMENT_NODE
end

# File 'ext/nokogiri/xml_node.c', line 770

static VALUE
rb_xml_node_content(VALUE self)
{
  xmlNodePtr node;
  xmlChar *content;

  Noko_Node_Get_Struct(self, xmlNode, node);

  content = xmlNodeGetContent(node);
  if (content) {
    VALUE rval = NOKOGIRI_STR_NEW2(content);
    xmlFree(content);
    return rval;
  }
  return Qnil;
}

# File 'lib/nokogiri/xml/node.rb', line 447

def content=(string)
  self.native_content = encode_special_chars(string.to_s)
end

# File 'ext/nokogiri/xml_node.c', line 2258

VALUE
rb_xml_node_data_ptr_eh(VALUE self)
{
  xmlNodePtr c_node;
  Noko_Node_Get_Struct(self, xmlNode, c_node);
  return c_node ? Qtrue : Qfalse;
}

# File 'lib/nokogiri/xml/node.rb', line 463

def default_namespace=(url)
  add_namespace_definition(nil, url)
end

# File 'ext/nokogiri/xml_node.c', line 795

static VALUE
rb_xml_node_document(VALUE self)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  return DOC_RUBY_OBJECT(node->doc);
}

# File 'lib/nokogiri/xml/node.rb', line 1186

def document?
  is_a?(XML::Document)
end

# File 'lib/nokogiri/xml/node.rb', line 1226

alias_method :elem?, :element?

# File 'lib/nokogiri/xml/node.rb', line 1222

def element?
  type == ELEMENT_NODE
end

# File 'lib/nokogiri/xml/node.rb', line 1201

def fragment?
  type == DOCUMENT_FRAG_NODE
end

# File 'lib/nokogiri/xml/node.rb', line 1181

def html?
  type == HTML_DOCUMENT_NODE
end

# File 'lib/nokogiri/xml/node.rb', line 1236

def inner_html(*args)
  children.map { |x| x.to_html(*args) }.join
end

# File 'lib/nokogiri/xml/node.rb', line 374

def inner_html=(node_or_tags)
  self.children = node_or_tags
end

# File 'lib/nokogiri/xml/node.rb', line 508

alias_method :inner_text, :content

# File 'ext/nokogiri/xml_node.c', line 1544

static VALUE
get_lang(VALUE self_rb)
{
  xmlNodePtr self ;
  xmlChar *lang ;
  VALUE lang_rb ;

  Noko_Node_Get_Struct(self_rb, xmlNode, self);

  lang = xmlNodeGetLang(self);
  if (lang) {
    lang_rb = NOKOGIRI_STR_NEW2(lang);
    xmlFree(lang);
    return lang_rb ;
  }

  return Qnil ;
}

# File 'ext/nokogiri/xml_node.c', line 1523

static VALUE
set_lang(VALUE self_rb, VALUE lang_rb)
{
  xmlNodePtr self ;
  xmlChar *lang ;

  Noko_Node_Get_Struct(self_rb, xmlNode, self);
  lang = (xmlChar *)StringValueCStr(lang_rb);

  xmlNodeSetLang(self, lang);

  return Qnil ;
}

# File 'ext/nokogiri/xml_node.c', line 2001

static VALUE
rb_xml_node_line(VALUE rb_node)
{
  xmlNodePtr c_node;
  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  return LONG2NUM(xmlGetLineNo(c_node));
}

# File 'ext/nokogiri/xml_node.c', line 2016

static VALUE
rb_xml_node_line_set(VALUE rb_node, VALUE rb_line_number)
{
  xmlNodePtr c_node;
  int line_number = NUM2INT(rb_line_number);

  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  // libxml2 optionally uses xmlNode.psvi to store longer line numbers, but only for text nodes.
  // search for "psvi" in SAX2.c and tree.c to learn more.
  if (line_number < 65535) {
    c_node->line = (short) line_number;
  } else {
    c_node->line = 65535;
    if (c_node->type == XML_TEXT_NODE) {
      c_node->psvi = (void *)(ptrdiff_t) line_number;
    }
  }

  return rb_line_number;
}

# File 'lib/nokogiri/xml/node.rb', line 511

alias_method :name, :node_name

# File 'ext/nokogiri/xml_node.c', line 1364

static VALUE
rb_xml_node_namespace(VALUE rb_node)
{
  xmlNodePtr c_node ;
  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  if (c_node->ns) {
    return noko_xml_namespace_wrap(c_node->ns, c_node->doc);
  }

  return Qnil ;
}

# File 'lib/nokogiri/xml/node.rb', line 473

def namespace=(ns)
  return set_namespace(ns) unless ns

  unless Nokogiri::XML::Namespace === ns
    raise TypeError, "#{ns.class} can't be coerced into Nokogiri::XML::Namespace"
  end
  if ns.document != document
    raise ArgumentError, "namespace must be declared on the same document"
  end

  set_namespace(ns)
end

# File 'ext/nokogiri/xml_node.c', line 1499

static VALUE
set_native_content(VALUE self, VALUE content)
{
  xmlNodePtr node, child, next ;
  Noko_Node_Get_Struct(self, xmlNode, node);

  child = node->children;
  while (NULL != child) {
    next = child->next ;
    xmlUnlinkNode(child) ;
    noko_xml_document_pin_node(child);
    child = next ;
  }

  xmlNodeSetContent(node, (xmlChar *)StringValueCStr(content));
  return content;
}

# File 'lib/nokogiri/xml/node.rb', line 498

alias_method :next, :next_sibling

# File 'lib/nokogiri/xml/node.rb', line 500

alias_method :next=, :add_next_sibling

# File 'ext/nokogiri/xml_node.c', line 1609

static VALUE
get_name(VALUE self)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  if (node->name) {
    return NOKOGIRI_STR_NEW2(node->name);
  }
  return Qnil;
}

# File 'ext/nokogiri/xml_node.c', line 1594

static VALUE
set_name(VALUE self, VALUE new_name)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  xmlNodeSetName(node, (xmlChar *)StringValueCStr(new_name));
  return new_name;
}

# File 'ext/nokogiri/xml_node.c', line 1576

static VALUE
get_parent(VALUE self)
{
  xmlNodePtr node, parent;
  Noko_Node_Get_Struct(self, xmlNode, node);

  parent = node->parent;
  if (!parent) { return Qnil; }

  return noko_xml_node_wrap(Qnil, parent) ;
}

# File 'lib/nokogiri/xml/node.rb', line 453

def parent=(parent_node)
  parent_node.add_child(self)
end

# File 'ext/nokogiri/xml_node.c', line 1829

static VALUE
rb_prepend_newline(VALUE self)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  return should_prepend_newline(node) ? Qtrue : Qfalse;
}

# File 'lib/nokogiri/xml/node.rb', line 499

alias_method :previous, :previous_sibling

# File 'lib/nokogiri/xml/node.rb', line 501

alias_method :previous=, :add_previous_sibling

# File 'lib/nokogiri/xml/node.rb', line 1191

def processing_instruction?
  type == PI_NODE
end

# File 'lib/nokogiri/xml/node.rb', line 1216

def read_only?
  # According to gdome2, these are read-only node types
  [NOTATION_NODE, ENTITY_NODE, ENTITY_DECL].include?(type)
end

# File 'lib/nokogiri/xml/node.rb', line 509

alias_method :text, :content

# File 'lib/nokogiri/xml/node.rb', line 1196

def text?
  type == TEXT_NODE
end

# File 'lib/nokogiri/xml/node.rb', line 510

alias_method :to_str, :content

# File 'lib/nokogiri/xml/node.rb', line 1176

def xml?
  type == DOCUMENT_NODE
end

# File 'lib/nokogiri/xml/node.rb', line 1297

def <=>(other)
  return unless other.is_a?(Nokogiri::XML::Node)
  return unless document == other.document

  compare(other)
end

# File 'lib/nokogiri/xml/node.rb', line 1287

def ==(other)
  return false unless other
  return false unless other.respond_to?(:pointer_id)

  pointer_id == other.pointer_id
end

# File 'lib/nokogiri/xml/node.rb', line 547

def [](name)
  get(name.to_s)
end

# File 'lib/nokogiri/xml/node.rb', line 585

def []=(name, value)
  set(name.to_s, value.to_s)
end

# File 'lib/nokogiri/xml/node.rb', line 1281

def accept(visitor)
  visitor.visit(self)
end

# File 'lib/nokogiri/xml/node.rb', line 184

def add_child(node_or_tags)
  node_or_tags = coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_child_node_and_reparent_attrs(n) }
  else
    add_child_node_and_reparent_attrs(node_or_tags)
  end
  node_or_tags
end

# File 'ext/nokogiri/xml_node.c', line 1564

static VALUE
add_child(VALUE self, VALUE new_child)
{
  return reparent_node_with(self, new_child, xmlAddChild);
}

# File 'lib/nokogiri/xml/node.rb', line 1603

def add_child_node_and_reparent_attrs(node)
  add_child_node(node)
  node.attribute_nodes.find_all { |a| a.name.include?(":") }.each do |attr_node|
    attr_node.remove
    node[attr_node.name] = attr_node.value
  end
end

# File 'lib/nokogiri/xml/node.rb', line 750

def add_class(names)
  kwattr_add("class", names)
end

# File 'lib/nokogiri/xml/node.rb', line 504

alias_method :add_namespace, :add_namespace_definition

# File 'ext/nokogiri/xml_node.c', line 466

static VALUE
rb_xml_node_add_namespace_definition(VALUE rb_node, VALUE rb_prefix, VALUE rb_href)
{
  xmlNodePtr c_node, element;
  xmlNsPtr c_namespace;
  const xmlChar *c_prefix = (const xmlChar *)(NIL_P(rb_prefix) ? NULL : StringValueCStr(rb_prefix));

  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
  element = c_node ;

  c_namespace = xmlSearchNs(c_node->doc, c_node, c_prefix);

  if (!c_namespace) {
    if (c_node->type != XML_ELEMENT_NODE) {
      element = c_node->parent;
    }
    c_namespace = xmlNewNs(element, (const xmlChar *)StringValueCStr(rb_href), c_prefix);
  }

  if (!c_namespace) {
    return Qnil ;
  }

  if (NIL_P(rb_prefix) || c_node != element) {
    xmlSetNs(c_node, c_namespace);
  }

  return noko_xml_namespace_wrap(c_namespace, c_node->doc);
}

# File 'lib/nokogiri/xml/node.rb', line 324

def add_next_sibling(node_or_tags)
  raise ArgumentError,
    "A document may not have multiple root nodes." if parent&.document? && !(node_or_tags.comment? || node_or_tags.processing_instruction?)

  add_sibling(:next, node_or_tags)
end

# File 'ext/nokogiri/xml_node.c', line 1650

static VALUE
add_next_sibling(VALUE self, VALUE new_sibling)
{
  return reparent_node_with(self, new_sibling, xmlAddNextSibling) ;
}

# File 'lib/nokogiri/xml/node.rb', line 307

def add_previous_sibling(node_or_tags)
  raise ArgumentError,
    "A document may not have multiple root nodes." if parent&.document? && !(node_or_tags.comment? || node_or_tags.processing_instruction?)

  add_sibling(:previous, node_or_tags)
end

# File 'ext/nokogiri/xml_node.c', line 1657

static VALUE
add_previous_sibling(VALUE self, VALUE new_sibling)
{
  return reparent_node_with(self, new_sibling, xmlAddPrevSibling) ;
}

# File 'lib/nokogiri/xml/node.rb', line 1558

def add_sibling(next_or_previous, node_or_tags)
  raise("Cannot add sibling to a node with no parent") unless parent

  impl = next_or_previous == :next ? :add_next_sibling_node : :add_previous_sibling_node
  iter = next_or_previous == :next ? :reverse_each : :each

  node_or_tags = parent.coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    if text?
      pivot = Nokogiri::XML::Node.new("dummy", document)
      send(impl, pivot)
    else
      pivot = self
    end
    node_or_tags.send(iter) { |n| pivot.send(impl, n) }
    pivot.unlink if text?
  else
    send(impl, node_or_tags)
  end
  node_or_tags
end

# File 'lib/nokogiri/xml/node.rb', line 354

def after(node_or_tags)
  add_next_sibling(node_or_tags)
  self
end

# File 'lib/nokogiri/xml/node.rb', line 1250

def ancestors(selector = nil)
  return NodeSet.new(document) unless respond_to?(:parent)
  return NodeSet.new(document) unless parent

  parents = [parent]

  while parents.last.respond_to?(:parent)
    break unless (ctx_parent = parents.last.parent)

    parents << ctx_parent
  end

  return NodeSet.new(document, parents) unless selector

  root = parents.last
  search_results = root.search(selector)

  NodeSet.new(document, parents.find_all do |parent|
    search_results.include?(parent)
  end)
end

# File 'lib/nokogiri/xml/node.rb', line 794

def append_class(names)
  kwattr_append("class", names)
end

# File 'lib/nokogiri/xml/node.rb', line 1042

alias_method :attr, :[]

# File 'ext/nokogiri/xml_node.c', line 535

static VALUE
rb_xml_node_attribute(VALUE self, VALUE name)
{
  xmlNodePtr node;
  xmlAttrPtr prop;
  Noko_Node_Get_Struct(self, xmlNode, node);
  prop = xmlHasProp(node, (xmlChar *)StringValueCStr(name));

  if (! prop) { return Qnil; }
  return noko_xml_node_wrap(Qnil, (xmlNodePtr)prop);
}

# File 'ext/nokogiri/xml_node.c', line 586

static VALUE
rb_xml_node_attribute_nodes(VALUE rb_node)
{
  xmlNodePtr c_node;

  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  return noko_xml_node_attrs(c_node);
}

# File 'ext/nokogiri/xml_node.c', line 638

static VALUE
rb_xml_node_attribute_with_ns(VALUE self, VALUE name, VALUE namespace)
{
  xmlNodePtr node;
  xmlAttrPtr prop;
  Noko_Node_Get_Struct(self, xmlNode, node);
  prop = xmlHasNsProp(node, (xmlChar *)StringValueCStr(name),
                      NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace));

  if (! prop) { return Qnil; }
  return noko_xml_node_wrap(Qnil, (xmlNodePtr)prop);
}

# File 'lib/nokogiri/xml/node.rb', line 644

def attributes
  attribute_nodes.each_with_object({}) do |node, hash|
    hash[node.node_name] = node
  end
end

# File 'lib/nokogiri/xml/node.rb', line 340

def before(node_or_tags)
  add_previous_sibling(node_or_tags)
  self
end

# File 'lib/nokogiri/xml/node.rb', line 1449

def canonicalize(mode = XML::XML_C14N_1_0, inclusive_namespaces = nil, with_comments = false)
  c14n_root = self
  document.canonicalize(mode, inclusive_namespaces, with_comments) do |node, parent|
    tn = node.is_a?(XML::Node) ? node : parent
    tn == c14n_root || tn.ancestors.include?(c14n_root)
  end
end

# File 'ext/nokogiri/xml_node.c', line 688

static VALUE
rb_xml_node_child(VALUE self)
{
  xmlNodePtr node, child;
  Noko_Node_Get_Struct(self, xmlNode, node);

  child = node->children;
  if (!child) { return Qnil; }

  return noko_xml_node_wrap(Qnil, child);
}

# File 'lib/nokogiri/xml/node.rb', line 704

def classes
  kwattr_values("class")
end

# File 'lib/nokogiri/xml/node.rb', line 162

def clone(level = 1, new_parent_doc = document)
  super().initialize_copy_with_args(self, level, new_parent_doc)
end

# File 'ext/nokogiri/xml_node.c', line 2102

static VALUE
compare(VALUE self, VALUE _other)
{
  xmlNodePtr node, other;
  Noko_Node_Get_Struct(self, xmlNode, node);
  Noko_Node_Get_Struct(_other, xmlNode, other);

  return INT2NUM(xmlXPathCmpNodes(other, node));
}

# File 'ext/nokogiri/xml_node.c', line 888

static VALUE
create_external_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
{
  xmlNodePtr node;
  xmlDocPtr doc;
  xmlDtdPtr dtd;

  Noko_Node_Get_Struct(self, xmlNode, node);

  doc = node->doc;

  if (doc->extSubset) {
    rb_raise(rb_eRuntimeError, "Document already has an external subset");
  }

  dtd = xmlNewDtd(
          doc,
          NIL_P(name)        ? NULL : (const xmlChar *)StringValueCStr(name),
          NIL_P(external_id) ? NULL : (const xmlChar *)StringValueCStr(external_id),
          NIL_P(system_id)   ? NULL : (const xmlChar *)StringValueCStr(system_id)
        );

  if (!dtd) { return Qnil; }

  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
}

# File 'ext/nokogiri/xml_node.c', line 855

static VALUE
create_internal_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
{
  xmlNodePtr node;
  xmlDocPtr doc;
  xmlDtdPtr dtd;

  Noko_Node_Get_Struct(self, xmlNode, node);

  doc = node->doc;

  if (xmlGetIntSubset(doc)) {
    rb_raise(rb_eRuntimeError, "Document already has an internal subset");
  }

  dtd = xmlCreateIntSubset(
          doc,
          NIL_P(name)        ? NULL : (const xmlChar *)StringValueCStr(name),
          NIL_P(external_id) ? NULL : (const xmlChar *)StringValueCStr(external_id),
          NIL_P(system_id)   ? NULL : (const xmlChar *)StringValueCStr(system_id)
        );

  if (!dtd) { return Qnil; }

  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
}

# File 'lib/nokogiri/xml/node.rb', line 1241

def css_path
  path.split(%r{/}).filter_map do |part|
    part.empty? ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)')
  end.join(" > ")
end

# File 'lib/nokogiri/xml/node.rb', line 1510

def deconstruct_keys(keys)
  requested_keys = DECONSTRUCT_KEYS & keys
  {}.tap do |values|
    requested_keys.each do |key|
      method = DECONSTRUCT_METHODS[key] || key
      values[key] = send(method)
    end
  end
end

# File 'lib/nokogiri/xml/node.rb', line 168

def decorate!
  document.decorate(self)
end

# File 'lib/nokogiri/xml/node.rb', line 1040

alias_method :delete, :remove_attribute

# File 'lib/nokogiri/xml/node.rb', line 1208

def description
  return if document.xml?

  Nokogiri::HTML4::ElementDescription[name]
end

# File 'lib/nokogiri/xml/node.rb', line 490

def do_xinclude(options = XML::ParseOptions::DEFAULT_XML)
  options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
  yield options if block_given?

  # call c extension
  process_xincludes(options.to_i)
end

# File 'ext/nokogiri/xml_node.c', line 2080

static VALUE
dump_html(VALUE self)
{
  xmlBufferPtr buf ;
  xmlNodePtr node ;
  VALUE html;

  Noko_Node_Get_Struct(self, xmlNode, node);

  buf = xmlBufferCreate() ;
  htmlNodeDump(buf, node->doc, node);
  html = NOKOGIRI_STR_NEW2(buf->content);
  xmlBufferFree(buf);
  return html ;
}

# File 'lib/nokogiri/xml/node.rb', line 144

def dup(level = 1, new_parent_doc = document)
  super().initialize_copy_with_args(self, level, new_parent_doc)
end

# File 'lib/nokogiri/xml/node.rb', line 670

def each
  attribute_nodes.each do |node|
    yield [node.node_name, node.value]
  end
end

# File 'ext/nokogiri/xml_node.c', line 1115

static VALUE
rb_xml_node_element_children(VALUE self)
{
  xmlNodePtr node;
  xmlNodePtr child;
  xmlNodeSetPtr set;
  VALUE document;
  VALUE node_set;

  Noko_Node_Get_Struct(self, xmlNode, node);

  child = xmlFirstElementChild(node);
  set = xmlXPathNodeSetCreate(child);

  document = DOC_RUBY_OBJECT(node->doc);

  if (!child) { return noko_xml_node_set_wrap(set, document); }

  child = xmlNextElementSibling(child);
  while (NULL != child) {
    xmlXPathNodeSetAddUnique(set, child);
    child = xmlNextElementSibling(child);
  }

  node_set = noko_xml_node_set_wrap(set, document);

  return node_set;
}

# File 'lib/nokogiri/xml/node.rb', line 513

alias_method :elements, :element_children

# File 'ext/nokogiri/xml_node.c', line 824

static VALUE
encode_special_chars(VALUE self, VALUE string)
{
  xmlNodePtr node;
  xmlChar *encoded;
  VALUE encoded_str;

  Noko_Node_Get_Struct(self, xmlNode, node);
  encoded = xmlEncodeSpecialChars(
              node->doc,
              (const xmlChar *)StringValueCStr(string)
            );

  encoded_str = NOKOGIRI_STR_NEW2(encoded);
  xmlFree(encoded);

  return encoded_str;
}

# File 'ext/nokogiri/xml_node.c', line 921

static VALUE
external_subset(VALUE self)
{
  xmlNodePtr node;
  xmlDocPtr doc;
  xmlDtdPtr dtd;

  Noko_Node_Get_Struct(self, xmlNode, node);

  if (!node->doc) { return Qnil; }

  doc = node->doc;
  dtd = doc->extSubset;

  if (!dtd) { return Qnil; }

  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
}

# File 'ext/nokogiri/xml_node.c', line 1159

static VALUE
rb_xml_node_first_element_child(VALUE self)
{
  xmlNodePtr node, child;
  Noko_Node_Get_Struct(self, xmlNode, node);

  child = xmlFirstElementChild(node);
  if (!child) { return Qnil; }

  return noko_xml_node_wrap(Qnil, child);
}

# File 'lib/nokogiri/xml/node.rb', line 1057

def fragment(tags)
  document.related_class("DocumentFragment").new(document, tags, self)
end

# File 'ext/nokogiri/xml_node.c', line 1277

static VALUE
get(VALUE self, VALUE rattribute)
{
  xmlNodePtr node;
  xmlChar *value = 0;
  VALUE rvalue;
  xmlChar *colon;
  xmlChar *attribute, *attr_name, *prefix;
  xmlNsPtr ns;

  if (NIL_P(rattribute)) { return Qnil; }

  Noko_Node_Get_Struct(self, xmlNode, node);
  attribute = xmlCharStrdup(StringValueCStr(rattribute));

  colon = DISCARD_CONST_QUAL_XMLCHAR(xmlStrchr(attribute, (const xmlChar)':'));
  if (colon) {
    /* split the attribute string into separate prefix and name by
     * null-terminating the prefix at the colon */
    prefix = attribute;
    attr_name = colon + 1;
    (*colon) = 0;

    ns = xmlSearchNs(node->doc, node, prefix);
    if (ns) {
      value = xmlGetNsProp(node, attr_name, ns->href);
    } else {
      value = xmlGetProp(node, (xmlChar *)StringValueCStr(rattribute));
    }
  } else {
    value = xmlGetNoNsProp(node, attribute);
  }

  xmlFree((void *)attribute);
  if (!value) { return Qnil; }

  rvalue = NOKOGIRI_STR_NEW2(value);
  xmlFree((void *)value);

  return rvalue ;
}

# File 'lib/nokogiri/xml/node.rb', line 1041

alias_method :get_attribute, :[]

# File 'lib/nokogiri/xml/node.rb', line 1044

alias_method :has_attribute?, :key?

# File 'ext/nokogiri/xml_node.c', line 1961

static VALUE
html_standard_serialize(
  VALUE self,
  VALUE preserve_newline
)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  VALUE output = rb_str_buf_new(4096);
  output_node(output, node, RTEST(preserve_newline));
  return output;
}

# File 'ext/nokogiri/xml_node.c', line 2149

static VALUE
in_context(VALUE self, VALUE _str, VALUE _options)
{
  xmlNodePtr node, list = 0, tmp, child_iter, node_children, doc_children;
  xmlNodeSetPtr set;
  xmlParserErrors error;
  VALUE doc, err;
  int doc_is_empty;

  Noko_Node_Get_Struct(self, xmlNode, node);

  doc = DOC_RUBY_OBJECT(node->doc);
  err = rb_iv_get(doc, "@errors");
  doc_is_empty = (node->doc->children == NULL) ? 1 : 0;
  node_children = node->children;
  doc_children  = node->doc->children;

  xmlSetStructuredErrorFunc((void *)err, Nokogiri_error_array_pusher);

  /* Twiddle global variable because of a bug in libxml2.
   * http://git.gnome.org/browse/libxml2/commit/?id=e20fb5a72c83cbfc8e4a8aa3943c6be8febadab7
   *
   * TODO: this is fixed, and HTML_PARSE_NOIMPLIED is defined, in libxml2 2.7.7
   */
#ifndef HTML_PARSE_NOIMPLIED
  htmlHandleOmittedElem(0);
#endif

  /* This function adds a fake node to the child of node.  If the parser
   * does not exit cleanly with XML_ERR_OK, the list is freed.  This can
   * leave the child pointers in a bad state if they were originally empty.
   *
   * http://git.gnome.org/browse/libxml2/tree/parser.c#n13177
   * */
  error = xmlParseInNodeContext(node, StringValuePtr(_str),
                                (int)RSTRING_LEN(_str),
                                (int)NUM2INT(_options), &list);

  /* xmlParseInNodeContext should not mutate the original document or node,
   * so reassigning these pointers should be OK.  The reason we're reassigning
   * is because if there were errors, it's possible for the child pointers
   * to be manipulated. */
  if (error != XML_ERR_OK) {
    node->doc->children = doc_children;
    node->children = node_children;
  }

  /* make sure parent/child pointers are coherent so an unlink will work
   * properly (#331)
   */
  child_iter = node->doc->children ;
  while (child_iter) {
    child_iter->parent = (xmlNodePtr)node->doc;
    child_iter = child_iter->next;
  }

#ifndef HTML_PARSE_NOIMPLIED
  htmlHandleOmittedElem(1);
#endif

  xmlSetStructuredErrorFunc(NULL, NULL);

  /*
   * Workaround for a libxml2 bug where a parsing error may leave a broken
   * node reference in node->doc->children.
   *
   * https://bugzilla.gnome.org/show_bug.cgi?id=668155
   *
   * This workaround is limited to when a parse error occurs, the document
   * went from having no children to having children, and the context node is
   * part of a document fragment.
   *
   * TODO: This was fixed in libxml 2.8.0 by 71a243d
   */
  if (error != XML_ERR_OK && doc_is_empty && node->doc->children != NULL) {
    child_iter = node;
    while (child_iter->parent) {
      child_iter = child_iter->parent;
    }

    if (child_iter->type == XML_DOCUMENT_FRAG_NODE) {
      node->doc->children = NULL;
    }
  }

  /* FIXME: This probably needs to handle more constants... */
  switch (error) {
    case XML_ERR_INTERNAL_ERROR:
    case XML_ERR_NO_MEMORY:
      rb_raise(rb_eRuntimeError, "error parsing fragment (%d)", error);
      break;
    default:
      break;
  }

  set = xmlXPathNodeSetCreate(NULL);

  while (list) {
    tmp = list->next;
    list->next = NULL;
    xmlXPathNodeSetAddUnique(set, list);
    noko_xml_document_pin_node(list);
    list = tmp;
  }

  return noko_xml_node_set_wrap(set, doc);
}

# File 'lib/nokogiri/xml/node.rb', line 1597

def inspect_attributes
  [:name, :namespace, :attribute_nodes, :children]
end

# File 'ext/nokogiri/xml_node.c', line 946

static VALUE
internal_subset(VALUE self)
{
  xmlNodePtr node;
  xmlDocPtr doc;
  xmlDtdPtr dtd;

  Noko_Node_Get_Struct(self, xmlNode, node);

  if (!node->doc) { return Qnil; }

  doc = node->doc;
  dtd = xmlGetIntSubset(doc);

  if (!dtd) { return Qnil; }

  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
}

# File 'ext/nokogiri/xml_node.c', line 1204

static VALUE
key_eh(VALUE self, VALUE attribute)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  if (xmlHasProp(node, (xmlChar *)StringValueCStr(attribute))) {
    return Qtrue;
  }
  return Qfalse;
}

# File 'lib/nokogiri/xml/node.rb', line 664

def keys
  attribute_nodes.map(&:node_name)
end

# File 'lib/nokogiri/xml/node.rb', line 1546

def keywordify(keywords)
  case keywords
  when Enumerable
    keywords
  when String
    keywords.scan(/\S+/)
  else
    raise ArgumentError,
      "Keyword attributes must be passed as either a String or an Enumerable, but received #{keywords.class}"
  end
end

# File 'lib/nokogiri/xml/node.rb', line 927

def kwattr_add(attribute_name, keywords)
  keywords = keywordify(keywords)
  current_kws = kwattr_values(attribute_name)
  new_kws = (current_kws + (keywords - current_kws)).join(" ")
  set_attribute(attribute_name, new_kws)
  self
end

# File 'lib/nokogiri/xml/node.rb', line 980

def kwattr_append(attribute_name, keywords)
  keywords = keywordify(keywords)
  current_kws = kwattr_values(attribute_name)
  new_kws = (current_kws + keywords).join(" ")
  set_attribute(attribute_name, new_kws)
  self
end

# File 'lib/nokogiri/xml/node.rb', line 1023

def kwattr_remove(attribute_name, keywords)
  if keywords.nil?
    remove_attribute(attribute_name)
    return self
  end

  keywords = keywordify(keywords)
  current_kws = kwattr_values(attribute_name)
  new_kws = current_kws - keywords
  if new_kws.empty?
    remove_attribute(attribute_name)
  else
    set_attribute(attribute_name, new_kws.join(" "))
  end
  self
end

# File 'lib/nokogiri/xml/node.rb', line 873

def kwattr_values(attribute_name)
  keywordify(get_attribute(attribute_name) || [])
end

# File 'ext/nokogiri/xml_node.c', line 1186

static VALUE
rb_xml_node_last_element_child(VALUE self)
{
  xmlNodePtr node, child;
  Noko_Node_Get_Struct(self, xmlNode, node);

  child = xmlLastElementChild(node);
  if (!child) { return Qnil; }

  return noko_xml_node_wrap(Qnil, child);
}

# File 'lib/nokogiri/xml/node.rb', line 1050

def matches?(selector)
  ancestors.last.search(selector).include?(self)
end

# File 'ext/nokogiri/xml_node.c', line 1405

static VALUE
namespace_definitions(VALUE rb_node)
{
  /* this code in the mode of xmlHasProp() */
  xmlNodePtr c_node ;
  xmlNsPtr c_namespace;
  VALUE definitions = rb_ary_new();

  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  c_namespace = c_node->nsDef;
  if (!c_namespace) {
    return definitions;
  }

  while (c_namespace != NULL) {
    rb_ary_push(definitions, noko_xml_namespace_wrap(c_namespace, c_node->doc));
    c_namespace = c_namespace->next;
  }

  return definitions;
}

# File 'ext/nokogiri/xml_node.c', line 1456

static VALUE
rb_xml_node_namespace_scopes(VALUE rb_node)
{
  xmlNodePtr c_node ;
  xmlNsPtr *namespaces;
  VALUE scopes = rb_ary_new();
  int j;

  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  namespaces = xmlGetNsList(c_node->doc, c_node);
  if (!namespaces) {
    return scopes;
  }

  for (j = 0 ; namespaces[j] != NULL ; ++j) {
    rb_ary_push(scopes, noko_xml_namespace_wrap(namespaces[j], c_node->doc));
  }

  xmlFree(namespaces);
  return scopes;
}

# File 'ext/nokogiri/xml_node.c', line 1221

static VALUE
namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  if (xmlHasNsProp(node, (xmlChar *)StringValueCStr(attribute),
                   NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace))) {
    return Qtrue;
  }
  return Qfalse;
}

# File 'lib/nokogiri/xml/node.rb', line 1157

def namespaces
  namespace_scopes.each_with_object({}) do |ns, hash|
    prefix = ns.prefix
    key = prefix ? "xmlns:#{prefix}" : "xmlns"
    hash[key] = ns.href
  end
end

# File 'ext/nokogiri/xml_node.c', line 1669

static VALUE
native_write_to(
  VALUE self,
  VALUE io,
  VALUE encoding,
  VALUE indent_string,
  VALUE options
)
{
  xmlNodePtr node;
  const char *before_indent;
  xmlSaveCtxtPtr savectx;

  Noko_Node_Get_Struct(self, xmlNode, node);

  xmlIndentTreeOutput = 1;

  before_indent = xmlTreeIndentString;

  xmlTreeIndentString = StringValueCStr(indent_string);

  savectx = xmlSaveToIO(
              (xmlOutputWriteCallback)noko_io_write,
              (xmlOutputCloseCallback)noko_io_close,
              (void *)io,
              RTEST(encoding) ? StringValueCStr(encoding) : NULL,
              (int)NUM2INT(options)
            );

  xmlSaveTree(savectx, node);
  xmlSaveClose(savectx);

  xmlTreeIndentString = before_indent;
  return io;
}

# File 'ext/nokogiri/xml_node.c', line 1045

static VALUE
next_element(VALUE self)
{
  xmlNodePtr node, sibling;
  Noko_Node_Get_Struct(self, xmlNode, node);

  sibling = xmlNextElementSibling(node);
  if (!sibling) { return Qnil; }

  return noko_xml_node_wrap(Qnil, sibling);
}

# File 'ext/nokogiri/xml_node.c', line 1009

static VALUE
next_sibling(VALUE self)
{
  xmlNodePtr node, sibling;
  Noko_Node_Get_Struct(self, xmlNode, node);

  sibling = node->next;
  if (!sibling) { return Qnil; }

  return noko_xml_node_wrap(Qnil, sibling) ;
}

# File 'ext/nokogiri/xml_node.c', line 1485

static VALUE
node_type(VALUE self)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  return INT2NUM(node->type);
}

# File 'lib/nokogiri/xml/node.rb', line 1065

def parse(string_or_io, options = nil)
  ##
  # When the current node is unparented and not an element node, use the
  # document as the parsing context instead. Otherwise, the in-context
  # parser cannot find an element or a document node.
  # Document Fragments are also not usable by the in-context parser.
  if !element? && !document? && (!parent || parent.fragment?)
    return document.parse(string_or_io, options)
  end

  options ||= (document.html? ? ParseOptions::DEFAULT_HTML : ParseOptions::DEFAULT_XML)
  options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
  yield options if block_given?

  contents = if string_or_io.respond_to?(:read)
    string_or_io.read
  else
    string_or_io
  end

  return Nokogiri::XML::NodeSet.new(document) if contents.empty?

  error_count = document.errors.length
  node_set = in_context(contents, options.to_i)
  if document.errors.length > error_count
    raise document.errors[error_count] unless options.recover?

    if node_set.empty?
      # libxml2 < 2.13 does not obey the recover option after encountering errors during
      # in_context parsing, and so this horrible hack is here to try to emulate recovery
      # behavior.
      #
      # (Note that HTML4 fragment parsing seems to have been fixed in abd74186, and XML
      # fragment parsing is fixed in 1c106edf. Both are in 2.13.)
      #
      # Unfortunately, this means we're no longer parsing "in context" and so namespaces that
      # would have been inherited from the context node won't be handled correctly. This hack
      # was written in 2010, and I regret it, because it's silently degrading functionality in
      # a way that's not easily prevented (or even detected).
      #
      # I think preferable behavior would be to either:
      #
      # a. add an error noting that we "fell back" and pointing the user to turning off the
      #    recover option
      # b. don't recover, but raise a sensible exception
      #
      # For context and background:
      # - https://github.com/sparklemotion/nokogiri/issues/313
      # - https://github.com/sparklemotion/nokogiri/issues/2092
      fragment = document.related_class("DocumentFragment").parse(contents)
      node_set = fragment.children
    end
  end
  node_set
end

# File 'ext/nokogiri/xml_node.c', line 1626

static VALUE
rb_xml_node_path(VALUE rb_node)
{
  xmlNodePtr c_node;
  xmlChar *c_path ;
  VALUE rval;

  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  c_path = xmlGetNodePath(c_node);
  if (c_path == NULL) {
    // see https://github.com/sparklemotion/nokogiri/issues/2250
    // this behavior is clearly undesirable, but is what libxml <= 2.9.10 returned, and so we
    // do this for now to preserve the behavior across libxml2 versions.
    rval = NOKOGIRI_STR_NEW2("?");
  } else {
    rval = NOKOGIRI_STR_NEW2(c_path);
    xmlFree(c_path);
  }

  return rval ;
}

# File 'ext/nokogiri/xml_node.c', line 810

static VALUE
rb_xml_node_pointer_id(VALUE self)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);

  return rb_uint2inum((uintptr_t)(node));
}

# File 'lib/nokogiri/xml/node.rb', line 204

def prepend_child(node_or_tags)
  if (first = children.first)
    # Mimic the error add_child would raise.
    raise "Document already has a root node" if document? && !(node_or_tags.comment? || node_or_tags.processing_instruction?)

    first.__send__(:add_sibling, :previous, node_or_tags)
  else
    add_child(node_or_tags)
  end
end

# File 'ext/nokogiri/xml_node.c', line 1063

static VALUE
previous_element(VALUE self)
{
  xmlNodePtr node, sibling;
  Noko_Node_Get_Struct(self, xmlNode, node);

  /*
   *  note that we don't use xmlPreviousElementSibling here because it's buggy pre-2.7.7.
   */
  sibling = node->prev;
  if (!sibling) { return Qnil; }

  while (sibling && sibling->type != XML_ELEMENT_NODE) {
    sibling = sibling->prev;
  }

  return sibling ? noko_xml_node_wrap(Qnil, sibling) : Qnil ;
}

# File 'ext/nokogiri/xml_node.c', line 1027

static VALUE
previous_sibling(VALUE self)
{
  xmlNodePtr node, sibling;
  Noko_Node_Get_Struct(self, xmlNode, node);

  sibling = node->prev;
  if (!sibling) { return Qnil; }

  return noko_xml_node_wrap(Qnil, sibling);
}

# File 'ext/nokogiri/xml_node.c', line 2120

static VALUE
process_xincludes(VALUE self, VALUE options)
{
  int rcode ;
  xmlNodePtr node;
  VALUE error_list = rb_ary_new();

  Noko_Node_Get_Struct(self, xmlNode, node);

  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
  rcode = xmlXIncludeProcessTreeFlags(node, (int)NUM2INT(options));
  xmlSetStructuredErrorFunc(NULL, NULL);

  if (rcode < 0) {
    xmlErrorConstPtr error;

    error = xmlGetLastError();
    if (error) {
      rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
    } else {
      rb_raise(rb_eRuntimeError, "Could not perform xinclude substitution");
    }
  }

  return self;
}

# File 'lib/nokogiri/xml/node.rb', line 502

alias_method :remove, :unlink

# File 'lib/nokogiri/xml/node.rb', line 678

def remove_attribute(name)
  attr = attributes[name].remove if key?(name)
  clear_xpath_context if Nokogiri.jruby?
  attr
end

# File 'lib/nokogiri/xml/node.rb', line 844

def remove_class(names = nil)
  kwattr_remove("class", names)
end

# File 'lib/nokogiri/xml/node.rb', line 405

def replace(node_or_tags)
  raise("Cannot replace a node with no parent") unless parent

  # We cannot replace a text node directly, otherwise libxml will return
  # an internal error at parser.c:13031, I don't know exactly why
  # libxml is trying to find a parent node that is an element or document
  # so I can't tell if this is bug in libxml or not. issue #775.
  if text?
    replacee = Nokogiri::XML::Node.new("dummy", document)
    add_previous_sibling_node(replacee)
    unlink
    return replacee.replace(node_or_tags)
  end

  node_or_tags = parent.coerce(node_or_tags)

  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_previous_sibling(n) }
    unlink
  else
    replace_node(node_or_tags)
  end
  node_or_tags
end