nokogiri-xml-range 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b9a05b01ac98bf6a41a88fa74ee6e7c12caebdf
+  data.tar.gz: 491dc04b1eb68735c18330a472b3645f62c01ac7
+SHA512:
+  metadata.gz: d197d502e3fc10c82510bc074ecdd04a728dffff385eb97f1e304504d7f325f92340285c66ab1abe99492f5fd222477bb16c2796970f492a6386ce1bc8374a74
+  data.tar.gz: 1f2606fa9df9778aa7c2ef4289d24f1469a8242e5ccbbda4cb2bda073ff581320442945d74c17ee1843fa808c804af53b1ba53f974fec653095424ee22eda144

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,2 @@
+doc/
+pkg/

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - ruby-head
+  - 2.2.3
+  - 2.1.7

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title "Nokogiri::XML::Range Documentation" --protected

data/COPYING.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/ChangeLog.md

@@ -0,0 +1,4 @@
+### 0.1.0 / 2015-09-05
+
+* Initial release:
+

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,155 @@
+Nokogiri::XML::Range
+====================
+
+[![Build Status](https://travis-ci.org/KitaitiMakoto/nokogiri-xml-range.svg?branch=master)](https://travis-ci.org/KitaitiMakoto/nokogiri-xml-range)
+[![Coverage Status](https://coveralls.io/repos/KitaitiMakoto/nokogiri-xml-range/badge.svg?branch=master&service=github)](https://coveralls.io/github/KitaitiMakoto/nokogiri-xml-range?branch=master)
+
+* [Homepage](https://rubygems.org/gems/nokogiri-xml-range)
+* [Documentation](http://rubydoc.info/gems/nokogiri-xml-range)
+* [Email](mailto:KitaitiMakoto at gmail.com)
+
+DOM Range implementation on Nokogiri
+
+Description
+-----------
+
+[Nokogiri][] DOM Range Implementatin based on [DOM Standard specification][range spec].
+
+[Nokogiri]: http://www.nokogiri.org/
+[range spec]: https://dom.spec.whatwg.org/#ranges
+
+Features
+--------
+
+`Nokogiri::XML::Range` expresses a range on DOM tree. It can:
+
+* test a node is in the range or not,
+* delete contents the range expresses from DOM tree,
+* extract contents alike,
+* clone contents alike,
+* surround the range by specified DOM element,
+* and so on...
+
+Examples
+--------
+
+### Initialization ###
+
+    require 'nokogiri/xml/range'
+    
+    doc = Nokogiri.XML(<<EOX)
+    <root>
+      <parent>
+        <child>child 1</child>
+        <child>child 2</child>
+      </parent>
+    </root>
+    EOX
+    parent = doc.search('parent')[0]
+    child1 = doc.search('child')[0]
+    child2 = doc.search('child')[1]
+    child1_text = child1.child
+    child2_text = child2.child
+    # Initialize range with nodes and offsets of start and end point
+    range = Nokogiri::XML::Range.new(child1_text, 0, child2_text, 5)
+    # This range expresses `child 1</child>\n        <child>child`
+
+### Deleting contents ###
+
+    range.delete_contents
+    puts doc
+    # <?xml version="1.0"?>
+    # <root>
+    #   <parent>
+    #     <child></child><child> 2</child>
+    #   </parent>
+    # </root>
+
+### Extracting contents ###
+
+`Nokogiri::XML::Range#extract_contents` remove the range from DOM tree and returns contents in the range.
+
+    extracted = range.extract_contents
+    # => #(DocumentFragment:0x3fa87891eaa0 {
+    #   name = "#document-fragment",
+    #   children = [
+    #     #(Element:0x3fa87891e12c { name = "child", children = [ #(Text "child 1")] }),
+    #     #(Text "\n        "),
+    #     #(Element:0x3fa8789177f0 { name = "child", children = [ #(Text "child")] })]
+    #   })
+    puts doc
+    # <?xml version="1.0"?>
+    # <root>
+    #   <parent>
+    #     <child></child><child> 2</child>
+    #   </parent>
+    # </root>
+    puts extracted
+    # <child>child 1</child>
+    #     <child>child</child>
+
+### Cloning contents ###
+
+    cloned = range.clone_contents
+    # => #(DocumentFragment:0x3fa87809fb90 {
+    #   name = "#document-fragment",
+    #   children = [
+    #     #(Element:0x3fa87809e394 { name = "child", children = [ #(Text "child 1")] }),
+    #     #(Text "\n        "),
+    #     #(Element:0x3fa87808dcd8 { name = "child", children = [ #(Text "child")] })]
+    #   })
+    puts cloned
+    # <child>child 1</child>
+    #     <child>child</child>
+
+`Nokogiri::XML::Range#clone_contents` doesn't affect original DOM tree.
+
+### Inserting node ###
+
+`Nokogiri::XML::Range#insert_node` inserts a node just before the range start point.
+
+    text = Nokogiri::XML::Text.new('inserted', doc)
+    # => #(Text "inserted")
+    range.insert_node text
+    puts doc
+    # <?xml version="1.0"?>
+    # <root>
+    #   <parent>
+    #     <child>insertedchild 1</child>
+    #     <child>child 2</child>
+    #   </parent>
+    # </root>
+
+### Surrounding range contents ###
+
+    range = Nokogiri::XML::Range.new(child1_text, 6, child1_text, 7)
+    number = Nokogiri::XML::Element.new('number', doc)
+    range.surround_contents number
+    puts doc
+    # <?xml version="1.0"?>
+    # <root>
+    #   <parent>
+    #     <child>child <number>1</number></child>
+    #     <child>child 2</child>
+    #   </parent>
+    # </root>
+
+Requirements
+------------
+
+* Ruby 2.1.0 or later
+* Nokogiri gem
+* C compiler like gcc to install Nokogiri gem
+* `patch` command to install Nokogiri gem
+
+Install
+-------
+
+    $ gem install nokogiri-xml-range
+
+Copyright
+---------
+
+Copyright (c) 2015 KITAITI Makoto
+
+See {file:COPYING.txt} for details.

data/Rakefile

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+task :default => :test
+
+begin
+  gem 'rubygems-tasks', '~> 0.2'
+  require 'rubygems/tasks'
+
+  Gem::Tasks.new
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install rubygems-tasks` to install Gem::Tasks."
+end
+
+begin
+  gem 'yard', '~> 0.8'
+  require 'yard'
+
+  YARD::Rake::YardocTask.new  
+rescue LoadError => e
+  task :yard do
+    abort "Please run `gem install yard` to install YARD."
+  end
+end
+task :doc => :yard
+
+require 'rake/testtask'
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end

data/lib/nokogiri/xml/range.rb

@@ -0,0 +1,583 @@
+# coding: utf-8
+require 'nokogiri/xml/range/version'
+require 'nokogiri'
+require 'nokogiri/xml/range/refinement'
+require 'nokogiri/xml/replacable'
+
+using Nokogiri::XML::Range::Refinement
+
+module Nokogiri::XML
+  class InvalidNodeTypeError < StandardError; end
+  class IndexSizeError < StandardError; end
+  class NotSupportedError < StandardError; end
+  class WrongDocumentError < StandardError; end
+  class HierarchyRequestError < StandardError; end
+  class NotFoundError < StandardError; end
+  class InvalidStateError < StandardError; end
+
+  class Range
+    START_TO_START = 0
+    START_TO_END = 1
+    END_TO_END = 2
+    END_TO_START = 3
+
+    class << self
+      def compare_points(node1, offset1, node2, offset2)
+        return unless node1.document == node2.document
+
+        case node1 <=> node2
+        when 0
+          offset1 <=> offset2
+        when 1
+          compare_points(node2, offset2, node1, offset1) * -1
+        else
+          ancestors = node2.ancestors_to(node1) # nil or [node2, parent of node2, ..., child of node1, node1]
+          if ancestors
+            child = nil
+            ancestors.reverse_each do |anc|
+              child = anc if anc.parent == node1
+            end
+            if node1.children.index(child) < offset1
+              1
+            else
+              -1
+            end
+          else
+            -1
+          end
+        end
+      end
+    end
+
+    attr_reader :start_container, :start_offset, :end_container, :end_offset
+    alias start_node start_container
+    alias end_node end_container
+
+    def initialize(start_container, start_offset, end_container, end_offset)
+      @start_container, @start_offset, @end_container, @end_offset =
+        start_container, start_offset, end_container, end_offset
+    end
+
+    def start_point
+      [@start_container, @start_offset]
+    end
+
+    def end_point
+      [@end_container, @end_offset]
+    end
+
+    def document
+      @start_container.document
+    end
+
+    def root
+      document.root
+    end
+
+    def set_start(node, offset)
+      validate_boundary_point node, offset
+      if document != node.document or
+        self.class.compare_points(node, offset, @end_container, @end_offset) == 1
+        set_end node, offset
+      end
+      @start_container, @start_offset = node, offset
+    end
+    alias start= set_start
+
+    def set_end(node, offset)
+      validate_boundary_point node, offset
+      if document != node.document or
+        self.class.compare_points(node, offset, @start_container, @start_offset) == -1
+        set_start node, offset
+      end
+      @end_container, @end_offset = node, offset
+    end
+    alias end= set_end
+
+    def set_start_before(node)
+      parent = node.parent
+      raise InvalidNodeTypeError, 'parent node is empty' unless parent
+      set_start(parent, parent.children.index(node))
+    end
+
+    def set_start_after(node)
+      parent = node.parent
+      raise InvalidNodeTypeError, 'parent node is empty' unless parent
+      set_start(parent, parent.children.index(node) + 1)
+    end
+
+    def set_end_before(node)
+      parent = node.parent
+      raise InvalidNodeTypeError, 'parent node is empty' unless parent
+      set_end(parent, parent.children.index(node))
+    end
+
+    def set_end_after(node)
+      parent = node.parent
+      raise InvalidNodeTypeError, 'parent node is empty' unless parent
+      set_end(parent, parent.children.index(node) + 1)
+    end
+
+    def collapsed?
+      @start_offset == @end_offset and
+        @start_container == @end_container
+    end
+
+    def collapse(to_start=false)
+      to_start ? set_end(*start_point) : set_start(*end_point)
+    end
+    alias collapse! collapse
+
+    def common_ancestor_container
+      container = @start_container
+      ancestors_of_end = [@end_container] + @end_container.ancestors
+      until ancestors_of_end.include?(container)
+        container = container.parent
+      end
+      container
+    end
+
+    def select_node(node)
+      parent = node.parent
+      raise InvalidNodeTypeError, 'parent node is empty' unless parent
+      index = parent.children.index(node)
+      set_start parent, index
+      set_end parent, index + 1
+    end
+
+    def select_node_contents(node)
+      raise InvalidNodeTypeError, 'document type declaration is passed' if node.type == Node::DOCUMENT_TYPE_NODE
+      set_start node, 0
+      set_end node, node.length
+    end
+
+    def compare_boundary_points(how, source_range)
+      raise WrongDocumentError, 'different document' unless source_range.document == document
+      this_point, other_point =
+        case how
+        when START_TO_START
+          [start_point, source_range.start_point]
+        when START_TO_END
+          [end_point, source_range.start_point]
+        when END_TO_END
+          [end_point, source_range.end_point]
+        when END_TO_START
+          [start_point, source_range.end_point]
+        else
+          raise NotSupportedError, 'unsupported way to compare'
+        end
+      self.class.compare_points(this_point[0], this_point[1], other_point[0], other_point[1])
+    end
+
+    def delete_contents
+      return if collapsed?
+
+      if @start_container == @end_container and @start_container.replacable?
+        @start_container.replace_data @start_offset, @end_offset - @start_offset, ''
+        return
+      end
+
+      nodes_to_remove = NodeSet.new(document)
+      common_ancestor = common_ancestor_container
+      select_containing_children common_ancestor, nodes_to_remove
+
+      if @end_container.ancestors_to @start_container
+        new_node, new_offset = @start_container, @start_offset
+      else
+        reference_node = @start_container
+        parent = reference_node.parent
+        while parent and !@end_container.ancestors_to(parent)
+          reference_node = parent
+          parent = reference_node.parent
+        end
+        new_node = parent
+        new_offset = parent.children.index(reference_node) + 1
+      end
+
+      if @start_container.replacable?
+        @start_container.replace_data @start_offset, @start_container.length - @start_offset, ''
+      end
+
+      nodes_to_remove.each &:remove
+
+      if @end_container.replacable?
+        @end_container.replace_data 0, @end_offset, ''
+      end
+
+      @start_container = @end_container = new_node
+      @start_offset = @end_offset = new_offset
+    end
+
+    def extract_contents
+      fragment = DocumentFragment.new(document)
+      return fragment if collapsed?
+
+      if @start_container == @end_container and @start_container.replacable?
+        cloned = @start_container.clone(0)
+        cloned.content = @start_container.substring_data(@start_offset, @end_offset - @start_offset)
+        fragment << cloned
+        @start_container.replace_data @start_offset, @end_offset - @start_offset, ''
+        return fragment
+      end
+      common_ancestor = common_ancestor_container
+      end_node_ancestors = [@end_container] + @end_container.ancestors
+      first_partially_contained_child =nil
+      unless end_node_ancestors.include? @start_container
+        first_partially_contained_child = common_ancestor.children.find {|child|
+          partially_contain_node? child
+        }
+      end
+      last_partially_contained_child = nil
+      unless @start_container.ancestors_to @end_container
+        last_partially_contained_child = common_ancestor.children.reverse_each.find {|child|
+          partially_contain_node? child
+        }
+      end
+      contained_children = common_ancestor.children.select {|child|
+        contain_node? child
+      }
+      raise HierarchyRequestError if contained_children.any? {|child|
+        child.type == Node::DOCUMENT_TYPE_NODE
+      }
+
+      if end_node_ancestors.include? @start_container
+        new_node, new_offset = @start_container, @start_offset
+      else
+        reference_node = @start_container
+        parent = reference_node.parent
+        while parent and !end_node_ancestors.include?(parent)
+          reference_node = reference_node.parent
+          parent = reference_node.parent
+        end
+        new_node = parent
+        new_offset = parent.children.index(reference_node) + 1
+      end
+
+      if first_partially_contained_child && first_partially_contained_child.replacable?
+
+        cloned = @start_container.clone(0)
+        cloned.content = @start_container.substring_data(@start_offset, @start_container.length - @start_offset)
+        fragment << cloned
+        @start_container.replace_data @start_offset, @start_container.length - @start_offset, ''
+      elsif first_partially_contained_child
+        cloned = first_partially_contained_child.clone(0)
+        fragment << cloned
+        subrange = Range.new(@start_container, @start_offset, first_partially_contained_child, first_partially_contained_child.length)
+        subfragment = subrange.extract_contents
+        cloned << subfragment
+      end
+      contained_children.each do |contained_child|
+        fragment << contained_child
+      end
+      if last_partially_contained_child && last_partially_contained_child.replacable?
+
+        cloned = @end_container.clone(0)
+        cloned.content = @end_container.substring_data(0, @end_offset)
+        fragment << cloned
+        @end_container.replace_data 0, @end_offset, ''
+      elsif last_partially_contained_child
+        cloned = last_partially_contained_child.clone(0)
+        fragment << cloned
+        subrange = Range.new(last_partially_contained_child, 0, @end_container, @end_offset)
+        subfragment = subrange.extract_contents
+        cloned << subfragment
+      end
+      @start_container = @end_container = new_node
+      @start_offset = @end_offset = new_offset
+      fragment
+    end
+
+    def clone_contents
+      fragment = DocumentFragment.new(document)
+      return fragment if collapsed?
+
+      if @start_container == @end_container and @start_container.replacable?
+        cloned = @start_container.clone(0)
+        cloned.content = @start_container.substring_data(@start_offset, @end_offset - @start_offset)
+        fragment << cloned
+        return fragment
+      end
+
+      common_ancestor = common_ancestor_container
+      first_partially_contained_child = nil
+      @end_node_ancestors = [@end_container] + @end_container.ancestors
+      unless @end_node_ancestors.include?(@start_container)
+        first_partially_contained_child = common_ancestor.children.find {|child|
+          partially_contain_node? child
+        }
+      end
+      last_partially_contained_child = nil
+      unless ([@start_container] + @start_container.ancestors).include? @end_container
+        last_partially_contained_child = common_ancestor.children.reverse_each.find {|child|
+          partially_contain_node? child
+        }
+      end
+
+      contained_children = common_ancestor.children.select {|child|
+        contain_node? child
+      }
+
+      raise HierarchyRequestError if contained_children.any? {|child|
+        child.type == Node::DOCUMENT_TYPE_NODE
+      }
+
+      if first_partially_contained_child && first_partially_contained_child.replacable?
+
+        cloned = @start_container.clone(0)
+        cloned.content = @start_container.substring_data(@start_offset, @start_container.length - @start_offset)
+        fragment << cloned
+      elsif first_partially_contained_child
+        cloned =first_partially_contained_child.clone(0)
+        fragment << cloned
+        subrange = self.class.new(@start_container, @start_offset, first_partially_contained_child, first_partially_contained_child.length)
+        subfragment = subrange.clone_contents
+        cloned << subfragment
+      end
+
+      contained_children.each do |contained_child|
+        cloned = contained_child.clone(1)
+        fragment << cloned
+      end
+
+      if last_partially_contained_child && last_partially_contained_child.replacable?
+        cloned = @end_container.clone(0)
+        cloned.content = @end_container.substring_data(0, @end_offset)
+        fragment << cloned
+      elsif last_partially_contained_child
+        cloned = last_partially_contained_child.clone(0)
+        fragment << cloned
+        subrange = self.class.new(last_partially_contained_child, 0, @end_container, @end_offset)
+        subfragment = subrange.clone_contents
+        cloned << subfragment
+      end
+
+      fragment
+    end
+
+    def insert_node(node)
+      if [Node::PI_NODE, Node::COMMENT_NODE].include?(@start_container.type) or
+        @start_container.text? && @start_container.parent.nil?
+        raise HierarchyRequestError
+      end
+      reference_node = nil
+      if @start_container.text?
+        reference_node = @start_container
+      else
+        reference_node = @start_container.children[@start_offset]
+      end
+      if reference_node
+        parent = reference_node.parent
+      else
+        parent = @start_container
+      end
+      node.validate_pre_insertion parent, reference_node
+      if @start_container.text?
+        #7 reference_node = @start_container.split()
+      end
+      # Nokogiri doesn't support serial text node,
+      # so we need to handle it ourselves
+      split_node = nil
+      if @start_container.text?
+        split_node = self.class.new(@start_container, @start_offset, @start_container, @start_container.length).extract_contents
+        reference_node = split_node
+      end
+      if node == reference_node
+        reference_node = node.next_sibling
+      end
+      if node.parent
+        node.remove
+      end
+      if reference_node
+        if split_node
+          @start_container.parent.children.index(@start_container) + 1
+        else
+          new_offset = reference_node.parent.children.index(reference_node)
+        end
+      else
+        new_offset = parent.length
+      end
+
+      # pre-insert
+      if split_node
+        # pre-insert validation node parent reference_node(@start_container or split_node)
+        unless [Node::DOCUMENT_NODE, Node::DOCUMENT_FRAG_NODE, Node::ELEMENT_NODE].include? parent.type
+          raise HierarchyRequestError
+        end
+        raise hierarchyrequesterror if parent.host_including_inclusive_ancestor? node
+        raise Hierarchyrequesterror if reference_node and @start_container.parent != parent
+        unless [Node::DOCUMENT_FRAG_NODE, Node::DOCUMENT_TYPE_NODE, Node::ELEMENT_NODE, Node::TEXT_NODE, Node::PI_NODE, Node::COMMENT_NODE].include? node.type
+          raise Hierarchyrequesterror
+        end
+        raise HierarchyRequestError if node.text? && parent.document?
+        raise HierarchyRequestError if node.type == Node::DOCUMENT_TYPE_NODE and !parent.document?
+        if parent.document?
+          case node.type
+          when Node::DOCUMENT_FRAG_NODE
+            child_element_count = 0
+            node.children.each do |n|
+              raise HierarchyRequestError if n.text?
+              child_element_count += 1 if n.element?
+              raise HierarchyRequestError if child_element_count > 1
+            end
+            if child_element_count == 1
+              raise HierarchyRequestError if parent.children.any?(&:element?)
+              if reference_node
+                raise HierarchyRequestError if reference_node.type == Node::DOCUMENT_TYPE_NODE
+                raise HierarchyRequestError if @start_container.following_node.type == Node::DOCUMENT_TYPE_NODE
+              end
+            end
+          when Node::ELEMENT_NODE
+            raise HierarchyRequestError if parent.children.any?(&:element?)
+            if reference_node
+              raise HierarchyRequestError if reference_node.child == Node::DOCUMENT_TYPE_NODE
+              raise HierarchyRequestError if @start_container.following_node.type == Node::DOCUMENT_TYPE_NODE
+            end
+          when Node::DOCUMENT_TYPE_NODE
+            raise HierarchyRequestError if parent.children.any? {|n|
+              n.type == Node::DOCUMENT_TYPE_NODE
+            }
+            if reference_node
+              raise HierarchyRequestError if @start_container.preceding_node.element?
+              raise HierarchyRequestError if parent.children.any?(&:element?)
+            end
+          end
+        end
+
+        reference_child = @start_container
+        if reference_child == parent
+          reference_child = split_node
+        end
+        parent.document.adopt node
+        @start_container.after node
+        node.after split_node
+      else
+        node.validate_pre_insertion parent, reference_node
+        reference_child = reference_node
+        if reference_child == parent
+          reference_child = parent.next_sibling
+        end
+        parent.document.adopt node
+        reference_child.before node
+      end
+
+      if collapsed?
+        @end_container, @end_offset = parent, new_offset
+      end
+    end
+
+    def surround_contents(new_parent)
+      raise InvalidStateError unless partially_containing_nodes.all?(&:text?)
+      raise InvalidNodeTypeError if [Node::DOCUMENT_NODE, Node::DOCUMENT_TYPE_NODE, Node::DOCUMENT_FRAG_NODE].include? new_parent.type
+      fragment = extract_contents
+      new_parent.replace_all_with nil if new_parent.child
+      insert_node new_parent
+      new_parent << fragment
+      select_node new_parent
+    end
+
+    def contain_node?(node)
+      document == node.document and
+        self.class.compare_points(node, 0, @start_container, @start_offset) == 1 and
+        self.class.compare_points(node, node.length, @end_container, @end_offset) == -1
+    end
+    alias include_node? contain_node?
+    alias cover_node? contain_node?
+
+    def containing_nodes
+      nodes = NodeSet.new(document)
+      select_containing_nodes common_ancestor_container, nodes
+
+      nodes
+    end
+
+    def partially_contain_node?(node)
+      path_to_start = @start_container.ancestors_to(node)
+      path_to_end = @end_container.ancestors_to(node)
+      !path_to_start.nil? && path_to_end.nil? or
+        path_to_start.nil? && !path_to_end.nil?
+    end
+    alias partially_include_node? partially_contain_node?
+    alias partially_cover_node? partially_contain_node?
+
+    def partially_containing_nodes
+      inclusive_ancestors_of_start = @start_container.inclusive_ancestors
+      inclusive_ancestors_of_end = @end_container.inclusive_ancestors
+      (inclusive_ancestors_of_start | inclusive_ancestors_of_end) -
+        (inclusive_ancestors_of_start & inclusive_ancestors_of_end)
+    end
+
+    def point_in_range?(node, offset)
+      return false unless node.ancestors.last == @start_container.ancestors.last
+      raise InvalidNodeTypeError if node.type == Node::DOCUMENT_TYPE_NODE
+      raise IndexSizeError if offset > node.length
+      return false if self.class.compare_points(node, offset, @start_container, @start_offset) == -1
+      return false if self.class.compare_points(node, offset, @end_container, @end_offset) == 1
+      true
+    end
+
+    def compare_point(node, offset)
+      raise WrongDocumentError unless node.ancestors.last == @start_container.ancestors.last
+      raise InvalidNodeTypeError if node.type == Node::DOCUMENT_TYPE_NODE
+      raise IndexSizeError if offset > node.length
+      return -1 if self.class.compare_points(node, offset, @start_container, @start_offset) == -1
+      return 1 if self.class.compare_points(node, offset, @end_container, @end_offset) == 1
+      0
+    end
+
+    def intersect_node?(node)
+      return false unless node.ancestors.last == @start_container.ancestors.last
+      return true unless node.respond_to?(:parent)
+      parent = node.parent
+      return true unless parent
+      offset = parent.children.index(node)
+      (self.class.compare_points(parent, offset, @end_container, @end_offset) == -1) and
+        (self.class.compare_points(parent, offset + 1, @start_container, @start_offset) == 1)
+    end
+
+    def to_s
+      s = ''
+      if @start_container == @end_container and @start_container.text?
+        return @start_container.substring_data(@start_offset, @end_offset - @start_offset)
+      end
+      if @start_container.text?
+        s << @start_container.substring_data(@start_offset, @start_container.length)
+      end
+      containing_nodes.reduce s do |concatenated, node|
+        concatenated << node.content if node.text?
+        concatenated
+      end
+      if @end_container.text?
+        s << @end_container.substring_data(0, @end_offset)
+      end
+      s
+    end
+
+    private
+
+    def validate_boundary_point(node, offset)
+      raise InvalidNodeTypeError, 'document type declaration cannot be a boundary point' if node.type == Node::DOCUMENT_TYPE_NODE
+      raise IndexSizeError, 'offset is greater than node length' if offset > node.length
+    end
+
+    # @note depth first order
+    # @note modifies +node_set+
+    def select_containing_children(node, node_set)
+      if contain_node?(node)
+        node_set << node
+      else
+        node.children.each do |child|
+          select_containing_children child, node_set
+        end
+      end
+    end
+
+    # @note depth first order
+    # @note modifies +node_set+
+    def select_containing_nodes(node, node_set)
+      node_set << node if contain_node?(node)
+      node.children.each do |child|
+        select_containing_nodes child, node_set
+      end
+    end
+  end
+end