nokogiri-xml-range 0.1.0

data/lib/nokogiri/xml/range/refinement.rb

@@ -0,0 +1,124 @@
+module Nokogiri::XML
+  class Range
+    module Refinement
+      refine Node do
+        def ancestors_to(node)
+          nodes = NodeSet.new(document)
+          current = self
+          root = document.root
+          nodes << current
+          until current == node or current == root
+            current = current.parent
+            nodes << current
+          end
+          return unless current == node
+          nodes
+        end
+
+        def length
+          case type
+          when Node::DOCUMENT_TYPE_NODE
+            0
+          when Node::TEXT_NODE, Node::CDATA_SECTION_NODE, Node::PI_NODE, Node::COMMENT_NODE
+            content.encode('UTF-16LE').bytesize / 2
+          else
+            children.length
+          end
+        end
+
+        def following_node
+          child || next_sibling
+        end
+
+        def preceding_node
+          previous_sibling || parent
+        end
+
+        def inclusive_ancestors
+          [self] + ancestors
+        end
+
+        def inclusive_ancestor?(node)
+          inclusive_ancestors.include? node
+        end
+
+        def host_including_inclusive_ancestor?(node)
+          return true if inclusive_ancestor? node
+          root_node = ancestors.last
+          root_node.fragment? and
+            root_node.host.host_including_inclusive_ancestor?(node)
+        end
+
+        def replace_all_with(node)
+          document.adopt node if node
+          children.each &:remove
+          if node
+            add_child node
+          end
+        end
+
+        def replacable?
+          kind_of? Nokogiri::XML::Replacable
+        end
+
+        def validate_pre_insertion(parent, child)
+          unless [Node::DOCUMENT_TYPE_NODE, Node::DOCUMENT_FRAG_NODE, Node::ELEMENT_NODE].include? parent.type
+            raise HierarchyRequestError
+          end
+          raise HierarchyRequestError if parent.host_including_inclusive_ancestor? self
+          raise NotFoundError if child and child.parent != parent
+          unless [Node::DOCUMENT_FRAG_NODE, Node::DOCUMENT_TYPE_NODE, Node::ELEMENT_NODE, Node::TEXT_NODE, Node::PI_NODE, Node::COMMENT_NODE].include? type
+            raise HierarchyRequestError
+          end
+          raise HierarchyRequestError if text? && parent.document?
+          raise HierarchyRequestError if type == Node::DOCUMENT_TYPE_NODE and !parent.document?
+          return unless parent.document?
+          case type
+          when Node::DOCUMENT_FRAG_NODE
+            child_element_count = 0
+            children.each do |node|
+              raise HierarchyRequestError if node.text?
+              child_element_count += 1 if node.element?
+              raise HierarchyRequestError if child_element_count > 1
+            end
+            if child_element_count == 1
+              raise HierarchyRequestError if parent.children.any?(&:element?)
+              return unless child
+              raise HierarchyRequestError if child.type = Node::DOCUMENT_TYPE_NODE
+              raise HierarchyRequestError if child.following_node.type == Node::DOCUMENT_TYPE_NODE
+            end
+          when Node::ELEMENT_NODE
+            raise HierarchyRequestError if parent.children.any?(&:element?)
+            return unless child
+            raise HierarchyRequestError if child.type == Node::DOCUMENT_TYPE_NODE
+            raise HierarchyRequestError if child.following_node.type == Node::DOCUMENT_TYPE_NODE
+          when Node::DOCUMENT_TYPE_NODE
+            raise HierarchyRequestError if parent.children.any? {|node|
+              node.type == Node::DOCUMENT_TYPE_NODE
+            }
+            return unless child
+            raise HierarchyRequestError if child.preceding_node.element?
+            raise HierarchyRequestError if parent.children.any?(&:element?)
+          end
+        end
+      end
+
+      refine Document do
+        def adopt(node)
+          old_document = node.document
+          unless node.document == self
+            root << node
+            node.remove
+          end
+          if block_given?
+            yield node, old_document
+          end
+        end
+      end
+
+      refine DocumentFragment do
+        attr_accessor :host
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/range/version.rb

@@ -0,0 +1,8 @@
+module Nokogiri
+  module XML
+    class Range
+      # nokogiri-xml-range version
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/nokogiri/xml/replacable.rb

@@ -0,0 +1,39 @@
+using Nokogiri::XML::Range::Refinement
+
+module Nokogiri::XML
+  module Replacable
+    def replace_data(offset, count, data)
+      len = length
+      raise IndexSizeError, 'offset is greater than node length' if offset > len
+
+      count = len - offset if offset + count > len
+      encoding = content.encoding
+      utf16_content = content.encode('UTF-16LE')
+      utf16_data = data.encode('UTF-16LE')
+      result = utf16_content.byteslice(0, offset * 2) + utf16_data + utf16_content.byteslice(offset * 2, utf16_content.bytesize)
+      delete_offset = offset + utf16_data.bytesize / 2
+      result = result.byteslice(0, delete_offset * 2) + result.byteslice((delete_offset + count) * 2, result.bytesize)
+
+      self.content = result.encode(encoding)
+    end
+
+    def substring_data(offset, count)
+      len = length
+      raise IndexSizeError, 'offset is greater than node length' if offset > len
+
+      encoding = content.encoding
+      utf16_content = content.encode('UTF-16LE')
+
+      byte_length = [utf16_content.bytesize - offset * 2, count * 2].min
+      utf16_content.byteslice(offset * 2, byte_length).encode(encoding)
+    end
+  end
+
+  class CharacterData
+    include Replacable
+  end
+
+  class ProcessingInstruction
+    include Replacable
+  end
+end

data/nokogiri-xml-range.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/nokogiri/xml/range/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "nokogiri-xml-range"
+  gem.version       = Nokogiri::XML::Range::VERSION
+  gem.summary       = %q{DOM Range implementation on Nokogiri}
+  gem.description   = %q{Nokogiri DOM Range Implementatin based on DOM Standard specification.}
+  gem.license       = "LGPL"
+  gem.authors       = ["KITAITI Makoto"]
+  gem.email         = "KitaitiMakoto@gmail.com"
+  gem.homepage      = "https://rubygems.org/gems/nokogiri-xml-range"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'nokogiri'
+
+  gem.add_development_dependency 'test-unit', '~> 3'
+  gem.add_development_dependency 'test-unit-notify'
+  gem.add_development_dependency 'rubygems-tasks', '~> 0.2'
+  gem.add_development_dependency 'yard', '~> 0.8'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'coveralls'
+end

data/test/helper.rb

@@ -0,0 +1,19 @@
+require 'simplecov'
+require 'coveralls'
+Coveralls.wear!
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter '/test/'
+end
+
+require 'pp'
+require 'rubygems'
+require 'test/unit'
+require 'test/unit/notify'
+require 'pry'
+
+class Test::Unit::TestCase
+end

data/test/test_nokogiri-xml-range-refinement.rb

@@ -0,0 +1,65 @@
+require 'helper'
+require 'nokogiri'
+require 'nokogiri/xml/range/refinement'
+require 'nokogiri/xml/replacable'
+
+class TestNokogiriXMLRangeRefinement < Test::Unit::TestCase
+  using Nokogiri::XML::Range::Refinement
+
+  def setup
+    @doc = Nokogiri.XML(<<EOD)
+<root>
+  <parent>
+    <child>child 1</child>
+    <child>child 2</child>
+  </parent>
+</root>
+EOD
+    @root = @doc.root
+    @parent = @root.search('parent').first
+    @child1 = @parent.search('child')[0]
+    @child2 = @parent.search('child')[1]
+  end
+
+  data({
+    'root' => [:root, 3],
+    'parent' => [:parent, 5],
+    'child1' => [:child1, 1],
+  })
+  def test_element_length(data)
+    node_name, length = data
+    node = instance_variable_get("@#{node_name}")
+    assert_equal length, node.length
+  end
+
+  def test_text_length
+    assert_equal 7, @child1.children[0].length
+  end
+
+  def test_inclusive_ancestor?
+    [@root, @parent, @child1].each do |node|
+      assert_true @child1.inclusive_ancestor? node
+    end
+    assert_false @child1.inclusive_ancestor? @child2
+  end
+
+  def test_host_including_inclusive_ancestor?
+    fragment = Nokogiri::XML::DocumentFragment.new(@doc)
+    fragment.host = @parent
+    child = Nokogiri::XML::Element.new('child', @doc)
+    fragment << child
+    assert_true child.host_including_inclusive_ancestor? @root
+  end
+
+  def test_adopt
+    @doc.adopt @child1
+    assert_equal @doc, @child1.document
+
+    another_doc = Nokogiri.XML('<root><child/></root>')
+    elem = another_doc.search('root').first
+    @doc.adopt elem
+    assert_equal @doc, elem.document
+    assert_equal @doc, elem.child.document
+    assert_equal Nokogiri.XML('').to_s, another_doc.to_s
+  end
+end

data/test/test_nokogiri-xml-range.rb

@@ -0,0 +1,316 @@
+# coding: utf-8
+require 'helper'
+require 'nokogiri/xml/range'
+
+class TestNokogiriXMLRange < Test::Unit::TestCase
+  def setup
+    @doc = Nokogiri.XML(<<EOX)
+<root>
+  <parent>
+    <child>child 1</child>
+    <child>child 2</child>
+  </parent>
+</root>
+EOX
+    @root = @doc.search('root')[0]
+    @parent = @doc.search('parent')[0]
+    @child1 = @doc.search('child')[0]
+    @child2 = @doc.search('child')[1]
+  end
+
+  def test_version
+    version = Nokogiri::XML::Range.const_get('VERSION')
+
+    assert !version.empty?, 'should have a VERSION constant'
+  end
+
+  def test_compare_points
+    assert_equal -1, Nokogiri::XML::Range.compare_points(@child1, 0, @child1, 1)
+    assert_equal 1, Nokogiri::XML::Range.compare_points(@child2, 0, @child1, 0)
+    assert_equal 0, Nokogiri::XML::Range.compare_points(@child1, 1, @child1, 1)
+    assert_equal -1, Nokogiri::XML::Range.compare_points(@doc.root, 0, @child1, 0)
+    assert_equal 1, Nokogiri::XML::Range.compare_points(@doc.root, 2, @child1, 1)
+    assert_equal -1, Nokogiri::XML::Range.compare_points(@child1, 0, @child2, 3)
+  end
+
+  def test_contain_node?
+    assert_true Nokogiri::XML::Range.new(@doc.root, 0, @child2, 0).contain_node?(@child1)
+    assert_false Nokogiri::XML::Range.new(@doc.root, 0, @child1, 1).contain_node?(@child2)
+  end
+
+  def test_partially_contain_node?
+    assert_false Nokogiri::XML::Range.new(@root, 0, @child1, 0).partially_contain_node?(@child2)
+    assert_false Nokogiri::XML::Range.new(@child1, 0, @child2, 0).partially_contain_node?(@root)
+    assert_false Nokogiri::XML::Range.new(@child1, 0, @child1, 1).partially_contain_node?(@child2)
+    assert_true Nokogiri::XML::Range.new(@child1.children[0], 0, @child2, 0).partially_contain_node?(@child1)
+  end
+
+  def test_common_ancestor_container
+    assert_equal @parent, Nokogiri::XML::Range.new(@child1, 0, @child2.children[0], 0).common_ancestor_container
+  end
+
+  def test_set_boundary_point
+    range1 = Nokogiri::XML::Range.new(@child1, 0, @child2, 0)
+    range2 = range1.dup
+
+    range1.set_start @parent, 1
+    assert_equal [@parent, 1], range1.start_point
+
+    range2.set_end @parent, 1
+    assert_equal [@parent, 1], range2.end_point
+    assert_equal [@parent, 1], range2.start_point
+  end
+
+  def test_set_start_before
+    range = Nokogiri::XML::Range.new(@child2, 0, @child2, 1)
+    range.set_start_before(@child1)
+
+    assert_equal [@parent, 1], range.start_point
+  end
+
+  def test_set_start_after
+    range = Nokogiri::XML::Range.new(@child2, 0, @child2, 1)
+    range.set_start_after(@child1)
+
+    assert_equal [@parent, 2], range.start_point
+  end
+
+  def test_set_end_before
+    range = Nokogiri::XML::Range.new(@child1, 0, @child2, 1)
+    range.set_end_before(@parent)
+
+    assert_equal [@root, 1], range.end_point
+  end
+
+  def test_set_end_after
+    range = Nokogiri::XML::Range.new(@child1, 0, @child2, 1)
+    range.set_end_after(@parent)
+
+    assert_equal [@root, 2], range.end_point
+  end
+
+  def test_collapse
+    range = Nokogiri::XML::Range.new(@child1, 0, @child2, 1)
+    range.collapse!
+
+    assert_equal [@child2, 1], range.start_point
+    assert_equal [@child2, 1], range.end_point
+  end
+
+  def test_select_node
+    range = Nokogiri::XML::Range.new(@child1, 0, @child2, 1)
+    range.select_node(@parent)
+
+    assert_equal [@root, 1], range.start_point
+    assert_equal [@root, 2], range.end_point
+  end
+
+  def test_select_node_contents
+    range = Nokogiri::XML::Range.new(@child1, 0, @child2, 1)
+    range.select_node_contents @child2
+
+    assert_equal [@child2, 0], range.start_point
+    assert_equal [@child2, 1], range.end_point
+  end
+
+  data(
+    {
+      'START_TO_START' => [-1, Nokogiri::XML::Range::START_TO_START],
+      'START_TO_END' => [1, Nokogiri::XML::Range::START_TO_END],
+      'END_TO_END' => [1, Nokogiri::XML::Range::END_TO_END],
+      'END_TO_START' => [-1, Nokogiri::XML::Range::END_TO_START]
+    }
+  )
+  def test_compare_boundary_points(data)
+    comparison, how = data
+
+    range1 = Nokogiri::XML::Range.new(@parent, 0, @child2, 1)
+    range2 = Nokogiri::XML::Range.new(@child1, 0, @parent, 3)
+
+    assert_equal comparison, range1.compare_boundary_points(how, range2)
+  end
+
+  def test_delete_contents_child_elements
+    range = Nokogiri::XML::Range.new(@child1, 0, @parent, 4)
+    range.delete_contents
+
+    assert_equal Nokogiri.XML(<<EXPECTED).to_s, @doc.to_s
+<root>
+  <parent>
+    <child/>
+  </parent>
+</root>
+EXPECTED
+  end
+
+  def test_delete_contents_text
+    range = Nokogiri::XML::Range.new(@child1.children[0], 1, @child1.children[0], 5)
+    range.delete_contents
+
+    assert_equal Nokogiri.XML(<<EXPECTED).to_s, @doc.to_s
+<root>
+  <parent>
+    <child>c 1</child>
+    <child>child 2</child>
+  </parent>
+</root>
+EXPECTED
+  end
+
+  def test_extract_contents_child_elements
+    range = Nokogiri::XML::Range.new(@child1, 0, @parent, 4)
+    range.extract_contents
+
+    assert_equal Nokogiri.XML(<<EXPECTED).to_s, @doc.to_s
+<root>
+  <parent>
+    <child/>
+  </parent>
+</root>
+EXPECTED
+  end
+
+  def test_extract_contents_text
+    range = Nokogiri::XML::Range.new(@child1.children[0], 1, @child1.children[0], 5)
+    range.extract_contents
+
+    assert_equal Nokogiri.XML(<<EXPECTED).to_s, @doc.to_s
+<root>
+  <parent>
+    <child>c 1</child>
+    <child>child 2</child>
+  </parent>
+</root>
+EXPECTED
+  end
+
+  def test_extract_contents_from_elements
+    range = Nokogiri::XML::Range.new(@child1.child, 1, @child2.child, 5)
+    extracted = range.extract_contents
+
+    assert_equal Nokogiri.XML(<<REMAINED).to_s, @doc.to_s
+<root>
+  <parent>
+    <child>c</child><child> 2</child>
+  </parent>
+</root>
+REMAINED
+    assert_equal <<EXTRACTED.chomp, extracted.to_s.chomp
+<child>hild 1</child>
+    <child>child</child>
+EXTRACTED
+  end
+
+  def test_extract_contents_from_text
+    range = Nokogiri::XML::Range.new(@child1.child, 1, @child1.child, 5)
+    extracted = range.extract_contents
+
+    assert_equal Nokogiri.XML(<<REMAINED).to_s, @doc.to_s
+<root>
+  <parent>
+    <child>c 1</child>
+    <child>child 2</child>
+  </parent>
+</root>
+REMAINED
+    assert_equal 'hild', extracted.to_s
+  end
+
+  def test_clone_contents_from_elements
+    range = Nokogiri::XML::Range.new(@child1.child, 1, @child2.child, 5)
+    cloned = range.clone_contents
+
+    assert_equal <<CLONED.chomp, cloned.to_s.chomp
+<child>hild 1</child>
+    <child>child</child>
+CLONED
+  end
+
+  def test_clone_contents_from_text
+    range = Nokogiri::XML::Range.new(@child1.child, 1, @child1.child, 5)
+    cloned = range.clone_contents
+
+    assert_equal 'hild', cloned.to_s
+  end
+
+  def test_insert_node_to_element
+    range = Nokogiri::XML::Range.new(@parent, 1, @parent, 3)
+    grand_child = Nokogiri::XML::Element.new('grand-child', @doc)
+    range.insert_node grand_child
+
+    assert_equal Nokogiri.XML(<<EOX).to_s, @doc.to_s
+<root>
+  <parent>
+    <grand-child/><child>child 1</child>
+    <child>child 2</child>
+  </parent>
+</root>
+EOX
+  end
+
+  def test_insert_node_to_text
+    range = Nokogiri::XML::Range.new(@child1.child, 5, @child1.child, 8)
+    text = Nokogiri::XML::Text.new('inserted', @doc)
+    range.insert_node text
+
+    assert_equal Nokogiri.XML(<<EOX).to_s, @doc.to_s
+<root>
+  <parent>
+    <child>childinserted 1</child>
+    <child>child 2</child>
+  </parent>
+</root>
+EOX
+  end
+
+  def test_surround_contents
+    range = Nokogiri::XML::Range.new(@child1.child, 6, @child1.child, 7)
+    number = Nokogiri::XML::Element.new('number', @doc)
+    range.surround_contents number
+
+    assert_equal Nokogiri.XML(<<EOX).to_s, @doc.to_s
+<root>
+  <parent>
+    <child>child <number>1</number></child>
+    <child>child 2</child>
+  </parent>
+</root>
+EOX
+  end
+
+  def test_point_in_range?
+    range = Nokogiri::XML::Range.new(@child1.child, 2, @parent, 4)
+
+    assert_true range.point_in_range? @child2, 0
+    assert_true range.point_in_range? @child1.child, 3
+  end
+
+  def test_compare_point
+    range = Nokogiri::XML::Range.new(@child1.child, 2, @parent, 4)
+
+    assert_equal -1, range.compare_point(@parent, 0)
+    assert_equal 0, range.compare_point(@child2, 0)
+    assert_equal 1, range.compare_point(@root, 2)
+  end
+
+  def test_intersect_node?
+    range = Nokogiri::XML::Range.new(@child1.child, 2, @parent, 4)
+
+    assert_true range.intersect_node? @child1.child
+  end
+
+  def test_to_s
+    assert_equal 'hild', Nokogiri::XML::Range.new(@child1.child, 1, @child1.child, 5).to_s
+    assert_equal <<EOS.chomp, Nokogiri::XML::Range.new(@root, 0, @root, 2).to_s
+
+  
+    child 1
+    child 2
+  
+EOS
+    assert_equal <<EOS.chomp, Nokogiri::XML::Range.new(@parent, 1, @child2.child, 5).to_s
+child 1
+    child
+EOS
+  end
+end