Nokogiri::XML::Node

static VALUE new(int argc, VALUE *argv, VALUE klass)
{
  xmlDocPtr doc;
  VALUE name;
  VALUE document;
  VALUE rest;

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

  Data_Get_Struct(document, xmlDoc, doc);

  xmlNodePtr node = xmlNewNode(NULL, (xmlChar *)StringValuePtr(name));
  node->doc = doc->doc;
  NOKOGIRI_ROOT_NODE(node);

  VALUE rb_node = Nokogiri_wrap_xml_node(klass, node);
  rb_funcall2(rb_node, rb_intern("initialize"), argc, argv);

  if(rb_block_given_p()) rb_yield(rb_node);

  return rb_node;
}

# File lib/nokogiri/xml/node.rb, line 80
      def initialize name, document
        # ... Ya.  This is empty on purpose.
      end

# File lib/nokogiri/xml/node.rb, line 636
      def <=> other
        return nil unless other.is_a?(Nokogiri::XML::Node)
        return nil unless document == other.document
        compare other
      end

# File lib/nokogiri/xml/node.rb, line 478
      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 203
      def [] name
        return nil unless key?(name.to_s)
        get(name.to_s)
      end

static VALUE set(VALUE self, VALUE property, VALUE value)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);

  xmlSetProp(node, (xmlChar *)StringValuePtr(property),
      (xmlChar *)StringValuePtr(value));

  return value;
}

# File lib/nokogiri/xml/node.rb, line 459
      def accept visitor
        visitor.visit(self)
      end

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

static VALUE add_namespace_definition(VALUE self, VALUE prefix, VALUE href)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);


  xmlNsPtr ns = xmlNewNs(
      node,
      (const xmlChar *)StringValuePtr(href),
      (const xmlChar *)(prefix == Qnil ? NULL : StringValuePtr(prefix))
  );

  if(!ns) {
    ns = xmlSearchNs(
        node->doc,
        node,
        (const xmlChar *)(prefix == Qnil ? NULL : StringValuePtr(prefix))
    );
  }

  if(Qnil == prefix) xmlSetNs(node, ns);

  return Nokogiri_wrap_xml_namespace(node->doc, ns);
}

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

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

# File lib/nokogiri/xml/node.rb, line 278
      def after data
        fragment(data).children.to_a.reverse.each do |node|
          add_next_sibling node
        end
        self
      end

# File lib/nokogiri/xml/node.rb, line 413
      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

        NodeSet.new(document, parents.find_all { |parent|
          parent.matches?(selector)
        })
      end

# File lib/nokogiri/xml/node.rb, line 196
      def at path, ns = document.root ? document.root.namespaces : {}
        search(path, ns).first
      end

static VALUE attr(VALUE self, VALUE name)
{
  xmlNodePtr node;
  xmlAttrPtr prop;
  Data_Get_Struct(self, xmlNode, node);
  prop = xmlHasProp(node, (xmlChar *)StringValuePtr(name));

  if(! prop) return Qnil;
  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop);
}

static VALUE attribute_nodes(VALUE self)
{
    /* this code in the mode of xmlHasProp() */
    xmlNodePtr node ;
    VALUE attr ;

    attr = rb_ary_new() ;
    Data_Get_Struct(self, xmlNode, node);

    Nokogiri_xml_node_properties(node, attr);

    return attr ;
}

static VALUE attribute_with_ns(VALUE self, VALUE name, VALUE namespace)
{
  xmlNodePtr node;
  xmlAttrPtr prop;
  Data_Get_Struct(self, xmlNode, node);
  prop = xmlHasNsProp(node, (xmlChar *)StringValuePtr(name),
      Qnil == namespace ? NULL : (xmlChar *)StringValuePtr(namespace));

  if(! prop) return Qnil;
  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop);
}

# File lib/nokogiri/xml/node.rb, line 226
      def attributes
        Hash[*(attribute_nodes.map { |node|
          [node.node_name, node]
        }.flatten)]
      end

# File lib/nokogiri/xml/node.rb, line 268
      def before data
        fragment(data).children.each do |node|
          add_previous_sibling node
        end
        self
      end

static VALUE blank_eh(VALUE self)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);
  if(1 == xmlIsBlankNode(node))
    return Qtrue;
  return Qfalse;
}

# File lib/nokogiri/xml/node.rb, line 343
      def cdata?
        type == CDATA_SECTION_NODE
      end

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

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

  return Nokogiri_wrap_xml_node(Qnil, child);
}

static VALUE children(VALUE self)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);

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

  if(!child) return Nokogiri_wrap_xml_node_set(set);

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

  VALUE node_set = Nokogiri_wrap_xml_node_set(set);
  rb_iv_set(node_set, "@document", DOC_RUBY_OBJECT(node->doc));

  return node_set;
}

# File lib/nokogiri/xml/node.rb, line 403
      def collect_namespaces
        # TODO: print warning message if a prefix refers to more than one URI in the document?
        ns = {}
        traverse {|j| ns.merge!(j.namespaces)}
        ns
      end

# File lib/nokogiri/xml/node.rb, line 338
      def comment?
        type == COMMENT_NODE
      end

static VALUE get_content(VALUE self)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);

  xmlChar * content = xmlNodeGetContent(node);
  if(content) {
    VALUE rval = NOKOGIRI_STR_NEW2(content, node->doc->encoding);
    xmlFree(content);
    return rval;
  }
  return Qnil;
}

# File lib/nokogiri/xml/node.rb, line 311
      def content= string
        self.native_content = encode_special_chars(string.to_s)
      end

# File lib/nokogiri/xml/node.rb, line 177
      def css *rules
        # Pop off our custom function handler if it exists
        handler = ![
          Hash, String, Symbol
        ].include?(rules.last.class) ? rules.pop : nil

        ns = rules.last.is_a?(Hash) ? rules.pop :
          (document.root ? document.root.namespaces : {})

        rules = rules.map { |rule|
          CSS.xpath_for(rule, :prefix => ".//", :ns => ns)
        }.flatten.uniq + [ns, handler].compact

        xpath(*rules)
      end

# File lib/nokogiri/xml/node.rb, line 396
      def css_path
        path.split(/\//).map { |part|
          part.length == 0 ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)')
        }.compact.join(' > ')
      end

# File lib/nokogiri/xml/node.rb, line 86
      def decorate!
        document.decorate(self)
      end

# File lib/nokogiri/xml/node.rb, line 433
      def default_namespace= url
        add_namespace_definition(nil, url)
      end

# File lib/nokogiri/xml/node.rb, line 365
      def description
        return nil if document.xml?
        Nokogiri::HTML::ElementDescription[name]
      end

# File lib/nokogiri/ffi/xml/node.rb, line 299
      def document
        cstruct.document.ruby_doc
      end

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

static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
{
  VALUE level;

  if(rb_scan_args(argc, argv, "01", &level) == 0)
    level = INT2NUM(1);

  xmlNodePtr node, dup;
  Data_Get_Struct(self, xmlNode, node);

  dup = xmlDocCopyNode(node, node->doc, NUM2INT(level));
  if(dup == NULL) return Qnil;

  return Nokogiri_wrap_xml_node(rb_obj_class(self), dup);
}

# File lib/nokogiri/xml/node.rb, line 246
      def each &block
        attribute_nodes.each { |node|
          block.call(node.node_name, node.value)
        }
      end

# File lib/nokogiri/xml/node.rb, line 378
      def element?
        type == ELEMENT_NODE
      end

static VALUE encode_special_chars(VALUE self, VALUE string)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);
  xmlChar * encoded = xmlEncodeSpecialChars(
      node->doc,
      (const xmlChar *)StringValuePtr(string)
  );

  VALUE encoded_str = NOKOGIRI_STR_NEW2(encoded, node->doc->encoding);
  xmlFree(encoded);

  return encoded_str;
}

# File lib/nokogiri/xml/node.rb, line 353
      def html?
        type == HTML_DOCUMENT_NODE
      end

# File lib/nokogiri/xml/node.rb, line 391
      def inner_html
        children.map { |x| x.to_html }.join
      end

# File lib/nokogiri/xml/node.rb, line 295
      def inner_html= tags
        children.each { |x| x.remove}

        fragment(tags).children.to_a.reverse.each do |node|
          add_child node
        end
        self
      end

static VALUE internal_subset(VALUE self)
{
  xmlNodePtr node;
  xmlDocPtr doc;
  Data_Get_Struct(self, xmlNode, node);

  if(!node->doc) return Qnil;

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

  if(!dtd) return Qnil;

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

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

# File lib/nokogiri/xml/node.rb, line 240
      def keys
        attribute_nodes.map { |node| node.node_name }
      end

static VALUE line(VALUE self)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);

  return INT2NUM(node->line);
}

# File lib/nokogiri/xml/node.rb, line 261
      def matches? selector
        document.search(selector).include?(self)
      end

static VALUE namespace(VALUE self)
{
  xmlNodePtr node ;
  Data_Get_Struct(self, xmlNode, node);

  if (node->ns)
    return Nokogiri_wrap_xml_namespace(node->doc, node->ns);

  return Qnil ;
}

# File lib/nokogiri/xml/node.rb, line 440
      def namespace= ns
        if ns.document != document
          raise ArgumentError, 'namespace must be declared on the same document'
        end
        unless ns.is_a? Nokogiri::XML::Namespace
          raise TypeError, "#{ns.class} can't be coerced into Nokogiri::XML::Namespace"
        end
        set_namespace ns
      end

static VALUE namespace_definitions(VALUE self)
{
  /* this code in the mode of xmlHasProp() */
  xmlNodePtr node ;

  Data_Get_Struct(self, xmlNode, node);

  VALUE list = rb_ary_new();

  xmlNsPtr ns = node->nsDef;

  if(!ns) return list;

  while(NULL != ns) {
    rb_ary_push(list, Nokogiri_wrap_xml_namespace(node->doc, ns));
    ns = ns->next;
  }

  return list;
}

static VALUE namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);
  if(xmlHasNsProp(node, (xmlChar *)StringValuePtr(attribute),
        Qnil == namespace ? NULL : (xmlChar *)StringValuePtr(namespace)))
    return Qtrue;
  return Qfalse;
}

# File lib/nokogiri/xml/node.rb, line 324
      def namespaces
        Hash[*namespace_definitions.map { |nd|
          key = ['xmlns', nd.prefix].compact.join(':')
          if RUBY_VERSION >= '1.9' && document.encoding
            begin
              key.force_encoding document.encoding
            rescue ArgumentError
            end
          end
          [key, nd.href]
        }.flatten]
      end

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

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

  return Nokogiri_wrap_xml_node(Qnil, sibling) ;
}

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

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

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

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

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

  return Nokogiri_wrap_xml_node(Qnil, parent) ;
}

# File lib/nokogiri/xml/node.rb, line 317
      def parent= parent_node
        parent_node.add_child(self)
        parent_node
      end

static VALUE path(VALUE self)
{
  xmlNodePtr node;
  xmlChar *path ;
  Data_Get_Struct(self, xmlNode, node);
  
  path = xmlGetNodePath(node);
  VALUE rval = NOKOGIRI_STR_NEW2(path, node->doc->encoding);
  xmlFree(path);
  return rval ;
}

static VALUE pointer_id(VALUE self)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);

  return INT2NUM((int)(node));
}

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

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

  return Nokogiri_wrap_xml_node(Qnil, sibling);
}

# File lib/nokogiri/xml/node.rb, line 372
      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 254
      def remove_attribute name
        attributes[name].remove if key? name
      end

# File lib/nokogiri/xml/node.rb, line 465
      def replace new_node
        if new_node.is_a?(Document) || !new_node.is_a?(XML::Node)
          raise ArgumentError, "Node.replace requires a Node argument, and cannot accept a Document.\n(You probably want to select a node from the Document with at() or search(), or create a new Node via Node.new().)\n"
        end
        replace_with_node new_node
      end

# File lib/nokogiri/xml/node.rb, line 94
      def search *paths
        ns = paths.last.is_a?(Hash) ? paths.pop :
          (document.root ? document.root.namespaces : {})
        xpath(*(paths.map { |path|
          path = path.to_s
          path =~ /^(\.\/|\/)/ ? path : CSS.xpath_for(
            path,
            :prefix => ".//",
            :ns     => ns
          )
        }.flatten.uniq) + [ns])
      end

# File lib/nokogiri/xml/node.rb, line 498
      def serialize *args, &block
        options = args.first.is_a?(Hash) ? args.shift : {
          :encoding   => args[0],
          :save_with  => args[1] || SaveOptions::FORMAT
        }

        io = StringIO.new
        write_to io, options, &block
        io.rewind
        io.read
      end

# File lib/nokogiri/ffi/xml/node.rb, line 105
      def set_namespace(namespace)
        LibXML.xmlSetNs(cstruct, namespace.cstruct)
        self
      end

# File lib/nokogiri/xml/node.rb, line 287
      def swap data
        before(data)
        remove
        self
      end

# File lib/nokogiri/xml/node.rb, line 358
      def text?
        type == TEXT_NODE
      end

# File lib/nokogiri/xml/node.rb, line 517
      def to_html options = {}
        # FIXME: this is a hack around broken libxml versions
        return dump_html if %w[2 6] === LIBXML_VERSION.split('.')[0..1]

        options[:save_with] ||= SaveOptions::FORMAT |
                                SaveOptions::NO_DECLARATION |
                                SaveOptions::NO_EMPTY_TAGS |
                                SaveOptions::AS_HTML

        serialize(options)
      end

# File lib/nokogiri/xml/node.rb, line 386
      def to_s
        document.xml? ? to_xml : to_html
      end

# File lib/nokogiri/xml/node.rb, line 549
      def to_xhtml options = {}
        # FIXME: this is a hack around broken libxml versions
        return dump_html if %w[2 6] === LIBXML_VERSION.split('.')[0..1]

        options[:save_with] ||= SaveOptions::FORMAT |
                                SaveOptions::NO_DECLARATION |
                                SaveOptions::NO_EMPTY_TAGS |
                                SaveOptions::AS_XHTML

        serialize(options)
      end

# File lib/nokogiri/xml/node.rb, line 535
      def to_xml options = {}
        encoding = nil

        options[:save_with] ||= SaveOptions::FORMAT | SaveOptions::AS_XML

        serialize(options)
      end

# File lib/nokogiri/xml/node.rb, line 452
      def traverse &block
        children.each{|j| j.traverse(&block) }
        block.call(self)
      end

static VALUE unlink_node(VALUE self)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);
  xmlUnlinkNode(node);
  NOKOGIRI_ROOT_NODE(node);
  return self;
}

# File lib/nokogiri/xml/node.rb, line 234
      def values
        attribute_nodes.map { |node| node.value }
      end

# File lib/nokogiri/xml/node.rb, line 596
      def write_html_to io, options = {}
        # FIXME: this is a hack around broken libxml versions
        return (io << dump_html) if %w[2 6] === LIBXML_VERSION.split('.')[0..1]

        options[:save_with] ||= SaveOptions::FORMAT |
          SaveOptions::NO_DECLARATION |
          SaveOptions::NO_EMPTY_TAGS |
          SaveOptions::AS_HTML
        write_to io, options
      end

# File lib/nokogiri/xml/node.rb, line 578
      def write_to io, *options
        options       = options.first.is_a?(Hash) ? options.shift : {}
        encoding      = options[:encoding] || options[0]
        save_options  = options[:save_with] || options[1] || SaveOptions::FORMAT
        indent_text   = options[:indent_text] || ' '
        indent_times  = options[:indent] || 2


        config = SaveOptions.new(save_options)
        yield config if block_given?

        native_write_to(io, encoding, indent_text * indent_times, config.options)
      end

# File lib/nokogiri/xml/node.rb, line 611
      def write_xhtml_to io, options = {}
        # FIXME: this is a hack around broken libxml versions
        return (io << dump_html) if %w[2 6] === LIBXML_VERSION.split('.')[0..1]

        options[:save_with] ||= SaveOptions::FORMAT |
          SaveOptions::NO_DECLARATION |
          SaveOptions::NO_EMPTY_TAGS |
          SaveOptions::AS_XHTML
        write_to io, options
      end

# File lib/nokogiri/xml/node.rb, line 628
      def write_xml_to io, options = {}
        options[:save_with] ||= SaveOptions::FORMAT | SaveOptions::AS_XML
        write_to io, options
      end

# File lib/nokogiri/xml/node.rb, line 348
      def xml?
        type == DOCUMENT_NODE
      end

# File lib/nokogiri/xml/node.rb, line 126
      def xpath *paths
        # Pop off our custom function handler if it exists
        handler = ![
          Hash, String, Symbol
        ].include?(paths.last.class) ? paths.pop : nil

        ns = paths.last.is_a?(Hash) ? paths.pop :
          (document.root ? document.root.namespaces : {})

        return NodeSet.new(document) unless document

        sets = paths.map { |path|
          ctx = XPathContext.new(self)
          ctx.register_namespaces(ns)
          set = ctx.evaluate(path, handler).node_set
          set.document = document
          document.decorate(set)
          set
        }
        return sets.first if sets.length == 1

        NodeSet.new(document) do |combined|
          document.decorate(combined)
          sets.each do |set|
            set.each do |node|
              combined << node
            end
          end
        end
      end

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

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

static VALUE dump_html(VALUE self)
{
  xmlBufferPtr buf ;
  xmlNodePtr node ;
  Data_Get_Struct(self, xmlNode, node);

  if(node->doc->type == XML_DOCUMENT_NODE)
    return rb_funcall(self, rb_intern("to_xml"), 0);

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

static VALUE get(VALUE self, VALUE attribute)
{
  xmlNodePtr node;
  xmlChar* propstr ;
  VALUE rval ;
  Data_Get_Struct(self, xmlNode, node);

  if(attribute == Qnil) return Qnil;

  propstr = xmlGetProp(node, (xmlChar *)StringValuePtr(attribute));

  if(NULL == propstr) return Qnil;

  rval = NOKOGIRI_STR_NEW2(propstr, node->doc->encoding);

  xmlFree(propstr);
  return rval ;
}

static VALUE set_content(VALUE self, VALUE content)
{
  xmlNodePtr node;
  Data_Get_Struct(self, xmlNode, node);
  xmlNodeSetContent(node, (xmlChar *)StringValuePtr(content));
  return content;
}

static VALUE native_write_to(
    VALUE self,
    VALUE io,
    VALUE encoding,
    VALUE indent_string,
    VALUE options
) 

static VALUE set_namespace(VALUE self, VALUE namespace)
{
  xmlNodePtr node;
  xmlNsPtr ns;

  Data_Get_Struct(self, xmlNode, node);
  Data_Get_Struct(namespace, xmlNs, ns);

  xmlSetNs(node, ns);

  return self;
}