tenderlove-nokogiri 0.0.0-x86-mswin32-60

data/test/xml/sax/test_parser.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', "helper"))
+
+module Nokogiri
+  module XML
+    module SAX
+      class TestParser < Nokogiri::SAX::TestCase
+        def setup
+          @parser = XML::SAX::Parser.new(Doc.new)
+        end
+
+        def test_parse
+          File.open(XML_FILE, 'rb') { |f|
+            @parser.parse(f)
+          }
+          @parser.parse(File.read(XML_FILE))
+        end
+
+        def test_parse_io
+          File.open(XML_FILE, 'rb') { |f|
+            @parser.parse_io(f)
+          }
+        end
+
+        def test_parse_file
+          @parser.parse_file(XML_FILE)
+          assert_raises(Errno::ENOENT) {
+            @parser.parse_file('')
+          }
+          assert_raises(Errno::EISDIR) {
+            @parser.parse_file(File.expand_path(File.dirname(__FILE__)))
+          }
+        end
+
+        def test_ctag
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">
+              <![CDATA[ This is a comment ]]>
+              Paragraph 1
+            </p>
+          eoxml
+          assert_equal [' This is a comment '], @parser.document.cdata_blocks
+        end
+
+        def test_comment
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">
+              <!-- This is a comment -->
+              Paragraph 1
+            </p>
+          eoxml
+          assert_equal [' This is a comment '], @parser.document.comments
+        end
+
+        def test_characters
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">Paragraph 1</p>
+          eoxml
+          assert_equal ['Paragraph 1'], @parser.document.data
+        end
+
+        def test_end_document
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">Paragraph 1</p>
+          eoxml
+          assert @parser.document.end_document_called
+        end
+
+        def test_end_element
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">Paragraph 1</p>
+          eoxml
+          assert_equal [["p"]],
+            @parser.document.end_elements
+        end
+
+        def test_start_element_attrs
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">Paragraph 1</p>
+          eoxml
+          assert_equal [["p", ["id", "asdfasdf"]]],
+                       @parser.document.start_elements
+        end
+
+        def test_parse_document
+          @parser.parse_memory(<<-eoxml)
+            <p>Paragraph 1</p>
+            <p>Paragraph 2</p>
+          eoxml
+        end
+      end
+    end
+  end
+end

data/test/xml/test_builder.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module XML
+    class TestBuilder < Nokogiri::TestCase
+      def test_cdata
+        builder = Nokogiri::XML::Builder.new do
+          root {
+            cdata "hello world"
+          }
+        end
+        assert_equal("<?xml version=\"1.0\"?><root><![CDATA[hello world]]></root>", builder.to_xml.gsub(/\n/, ''))
+      end
+    end
+  end
+end

data/test/xml/test_cdata.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module XML
+    class TestCDATA < Nokogiri::TestCase
+      def setup
+        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+      end
+
+      def test_cdata_node
+        name = @xml.xpath('//employee[2]/name').first
+        assert cdata = name.children[1]
+        assert cdata.cdata?
+        assert_equal 'cdata-section', cdata.name
+      end
+    end
+  end
+end

data/test/xml/test_document.rb

@@ -0,0 +1,171 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module XML
+    class TestDocument < Nokogiri::TestCase
+      def setup
+        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+      end
+
+      def test_XML_function
+        xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE)
+        assert xml.xml?
+      end
+
+      def test_document_name
+        xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE)
+        assert_equal 'document', xml.name
+      end
+
+      def test_parse_can_take_io
+        xml = nil
+        File.open(XML_FILE, 'rb') { |f|
+          xml = Nokogiri::XML(f)
+        }
+        assert xml.xml?
+      end
+
+      def test_search_on_empty_documents
+        doc = Nokogiri::XML::Document.new
+        ns = doc.search('//foo')
+        assert_equal 0, ns.length
+      end
+
+      def test_new_document_collect_namespaces
+        doc = Nokogiri::XML::Document.new
+        assert_equal({}, doc.collect_namespaces)
+      end
+
+      def test_find_with_namespace
+        doc = Nokogiri::XML.parse(<<-eoxml)
+        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+        </x>
+        eoxml
+
+        ctx = Nokogiri::XML::XPathContext.new(doc)
+        ctx.register_ns 'tenderlove', 'http://tenderlovemaking.com/'
+        set = ctx.evaluate('//tenderlove:foo').node_set
+        assert_equal 1, set.length
+        assert_equal 'foo', set.first.name
+
+        # It looks like only the URI is important:
+        ctx = Nokogiri::XML::XPathContext.new(doc)
+        ctx.register_ns 'america', 'http://tenderlovemaking.com/'
+        set = ctx.evaluate('//america:foo').node_set
+        assert_equal 1, set.length
+        assert_equal 'foo', set.first.name
+
+        # Its so important that a missing slash will cause it to return nothing
+        ctx = Nokogiri::XML::XPathContext.new(doc)
+        ctx.register_ns 'america', 'http://tenderlovemaking.com'
+        set = ctx.evaluate('//america:foo').node_set
+        assert_equal 0, set.length
+      end
+
+      def test_xml?
+        assert @xml.xml?
+      end
+
+      def test_document
+        assert @xml.document
+      end
+
+      def test_multiple_search
+        assert node_set = @xml.search('//employee', '//name')
+        employees = @xml.search('//employee')
+        names = @xml.search('//name')
+        assert_equal(employees.length + names.length, node_set.length)
+      end
+
+      def test_node_set_index
+        assert node_set = @xml.search('//employee')
+
+        assert_equal(5, node_set.length)
+        assert node_set[4]
+        assert_nil node_set[5]
+      end
+
+      def test_search
+        assert node_set = @xml.search('//employee')
+
+        assert_equal(5, node_set.length)
+
+        node_set.each do |node|
+          assert_equal('employee', node.name)
+        end
+      end
+
+      def test_dump
+        assert @xml.serialize
+        assert @xml.to_xml
+      end
+
+      def test_subset_is_decorated
+        x = Module.new do
+          def awesome!
+          end
+        end
+        util_decorate(@xml, x)
+
+        assert @xml.respond_to?(:awesome!)
+        assert node_set = @xml.search('//staff')
+        assert node_set.respond_to?(:awesome!)
+        assert subset = node_set.search('.//employee')
+        assert subset.respond_to?(:awesome!)
+        assert sub_subset = node_set.search('.//name')
+        assert sub_subset.respond_to?(:awesome!)
+      end
+
+      def test_decorator_is_applied
+        x = Module.new do
+          def awesome!
+          end
+        end
+        util_decorate(@xml, x)
+
+        assert @xml.respond_to?(:awesome!)
+        assert node_set = @xml.search('//employee')
+        assert node_set.respond_to?(:awesome!)
+        node_set.each do |node|
+          assert node.respond_to?(:awesome!), node.class
+        end
+        assert @xml.root.respond_to?(:awesome!)
+      end
+
+      def test_new
+        doc = nil
+        assert_nothing_raised {
+          doc = Nokogiri::XML::Document.new
+        }
+        assert doc
+        assert doc.xml?
+        assert_nil doc.root
+      end
+
+      def test_set_root
+        doc = nil
+        assert_nothing_raised {
+          doc = Nokogiri::XML::Document.new
+        }
+        assert doc
+        assert doc.xml?
+        assert_nil doc.root
+        node = Nokogiri::XML::Node.new("b") { |n|
+          n.content = 'hello world'
+        }
+        assert_equal('hello world', node.content)
+        doc.root = node
+        assert_equal(node, doc.root)
+      end
+
+      def util_decorate(document, x)
+        document.decorators['document'] << x
+        document.decorators['node'] << x
+        document.decorators['element'] << x
+        document.decorators['nodeset'] << x
+        document.decorate!
+      end
+    end
+  end
+end

data/test/xml/test_dtd.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module HTML
+    class TestDTD < Nokogiri::TestCase
+      def setup
+        @xml = Nokogiri::XML.parse(File.read(XML_FILE))
+        assert @dtd = @xml.internal_subset
+      end
+
+      def test_external_subsets
+        assert subset = @xml.internal_subset
+        assert_equal 'staff', subset.name
+      end
+
+      def test_entities
+        assert entities = @dtd.entities
+        assert_equal %w[ ent1 ent2 ent3 ent4 ent5 ].sort, entities.keys.sort
+      end
+
+      def test_attributes
+        assert attributes = @dtd.attributes
+        assert_equal %w[ width ], attributes.keys
+        assert_equal 'width', attributes['width'].name
+      end
+
+      def test_elements
+        assert elements = @dtd.elements
+        assert_equal %w[ br ], elements.keys
+        assert_equal 'br', elements['br'].name
+      end
+
+      def test_notations
+        assert notations = @dtd.notations
+        assert_equal %w[ notation1 notation2 ].sort, notations.keys.sort
+        assert notation1 = notations['notation1']
+        assert_equal 'notation1', notation1.name
+        assert_equal 'notation1File', notation1.public_id
+        assert_nil notation1.system_id
+      end
+    end
+  end
+end

data/test/xml/test_node.rb

@@ -0,0 +1,223 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module XML
+    class TestNode < Nokogiri::TestCase
+      def test_find_by_css_with_tilde_eql
+        xml = Nokogiri::XML.parse(<<-eoxml)
+        <root>
+          <a>Hello world</a>
+          <a class='foo bar'>Bar</a>
+          <a class='bar foo'>Bar</a>
+          <a class='bar'>Bar</a>
+          <a class='baz bar foo'>Bar</a>
+          <a class='bazbarfoo'>Awesome</a>
+          <a class='bazbar'>Awesome</a>
+        </root>
+        eoxml
+        set = xml.css('a[@class~="bar"]')
+        assert_equal 4, set.length
+        assert_equal ['Bar'], set.map { |node| node.content }.uniq
+      end
+
+      def test_unlink
+        xml = Nokogiri::XML.parse(<<-eoxml)
+        <root>
+          <a class='foo bar'>Bar</a>
+          <a class='bar foo'>Bar</a>
+          <a class='bar'>Bar</a>
+          <a>Hello world</a>
+          <a class='baz bar foo'>Bar</a>
+          <a class='bazbarfoo'>Awesome</a>
+          <a class='bazbar'>Awesome</a>
+        </root>
+        eoxml
+        node = xml.xpath('//a')[3]
+        assert_equal('Hello world', node.text)
+        assert_match(/Hello world/, xml.to_s)
+        assert node.parent
+        assert node.document
+        assert node.previous_sibling
+        assert node.next_sibling
+        assert node.instance_eval{ owned? }
+        node.unlink
+        assert !node.parent
+        # assert !node.document # ugh. libxml doesn't clear node->doc pointer, due to xmlDict implementation.
+        assert !node.previous_sibling
+        assert !node.next_sibling
+        assert !node.instance_eval{ owned? }
+        assert_no_match(/Hello world/, xml.to_s)
+      end
+
+      def test_dup
+        html = Nokogiri::HTML.parse(File.read(HTML_FILE), HTML_FILE)
+        found = html.search('//div/a').first
+        dup = found.dup
+        assert dup
+        assert_equal found.content, dup.content
+      end
+
+      def test_search_can_handle_xpath_and_css
+        html = Nokogiri::HTML.parse(File.read(HTML_FILE), HTML_FILE)
+        found = html.search('//div/a', 'div > p')
+        length = html.xpath('//div/a').length +
+          html.css('div > p').length
+        assert_equal length, found.length
+      end
+
+      def test_find_by_xpath
+        html = Nokogiri::HTML.parse(File.read(HTML_FILE), HTML_FILE)
+        found = html.xpath('//div/a')
+        assert_equal 3, found.length
+      end
+
+      def test_find_by_css
+        html = Nokogiri::HTML.parse(File.read(HTML_FILE), HTML_FILE)
+        found = html.css('div > a')
+        assert_equal 3, found.length
+      end
+
+      def test_next_sibling
+        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        assert node = xml.root
+        assert sibling = node.child.next_sibling
+        assert_equal('employee', sibling.name)
+      end
+
+      def test_previous_sibling
+        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        assert node = xml.root
+        assert sibling = node.child.next_sibling
+        assert_equal('employee', sibling.name)
+        assert_equal(sibling.previous_sibling, node.child)
+      end
+
+      def test_name=
+        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        assert node = xml.root
+        node.name = 'awesome'
+        assert_equal('awesome', node.name)
+      end
+
+      def test_child
+        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        assert node = xml.root
+        assert child = node.child
+        assert_equal('text', child.name)
+      end
+
+      def test_key?
+        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        assert node = xml.search('//address').first
+        assert(!node.key?('asdfasdf'))
+      end
+
+      def test_set_property
+        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        assert node = xml.search('//address').first
+        node['foo'] = 'bar'
+        assert_equal('bar', node['foo'])
+      end
+
+      def test_attributes
+        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        assert node = xml.search('//address').first
+        assert_nil(node['asdfasdfasdf'])
+        assert_equal('Yes', node['domestic'])
+
+        assert node = xml.search('//address')[2]
+        attr = node.attributes
+        assert_equal 2, attr.size
+        assert_equal 'Yes', attr['domestic']
+        assert_equal 'No', attr['street']
+      end
+
+      def test_path
+        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        assert set = xml.search('//employee')
+        assert node = set.first
+        assert_equal('/staff/employee[1]', node.path)
+      end
+
+      def test_new_node
+        node = Nokogiri::XML::Node.new('form')
+        assert_equal('form', node.name)
+        assert_nil(node.document)
+      end
+
+      def test_content
+        node = Nokogiri::XML::Node.new('form')
+        assert_equal('', node.content)
+
+        node.content = 'hello world!'
+        assert_equal('hello world!', node.content)
+      end
+
+      def test_replace
+        xml = Nokogiri::XML.parse(File.read(XML_FILE))
+        set = xml.search('//employee')
+        assert 5, set.length
+        assert 0, xml.search('//form').length
+
+        first = set[0]
+        second = set[1]
+
+        node = Nokogiri::XML::Node.new('form')
+        first.replace(node)
+
+        assert set = xml.search('//employee')
+        assert_equal 4, set.length
+        assert 1, xml.search('//form').length
+
+        assert_equal set[0].to_xml, second.to_xml
+      end
+
+      def test_namespace_as_hash
+        xml = Nokogiri::XML.parse(<<-eoxml)
+<root>
+ <car xmlns:part="http://general-motors.com/">
+  <part:tire>Michelin Model XGV</part:tire>
+ </car>
+ <bicycle xmlns:part="http://schwinn.com/">
+  <part:tire>I'm a bicycle tire!</part:tire>
+ </bicycle>
+</root>
+        eoxml
+
+        tires = xml.xpath('//bike:tire', {'bike' => 'http://schwinn.com/'})
+        assert_equal 1, tires.length
+      end
+
+      def test_namespaces
+        xml = Nokogiri::XML.parse(<<-EOF)
+<x xmlns:a='http://foo.com/' xmlns:b='http://bar.com/'>
+  <y xmlns:c='http://bazz.com/'>
+    <a:div>hello a</a:div>
+    <b:div>hello b</b:div>
+    <c:div>hello c</c:div>
+  </y>  
+</x>
+EOF
+        assert namespaces = xml.root.namespaces
+        assert namespaces.key?('xmlns:a')
+        assert_equal 'http://foo.com/', namespaces['xmlns:a']
+        assert namespaces.key?('xmlns:b')
+        assert_equal 'http://bar.com/', namespaces['xmlns:b']
+        assert ! namespaces.key?('xmlns:c')
+
+        assert namespaces = xml.namespaces
+        assert namespaces.key?('xmlns:a')
+        assert_equal 'http://foo.com/', namespaces['xmlns:a']
+        assert namespaces.key?('xmlns:b')
+        assert_equal 'http://bar.com/', namespaces['xmlns:b']
+        assert namespaces.key?('xmlns:c')
+        assert_equal 'http://bazz.com/', namespaces['xmlns:c']
+
+        assert_equal "hello a", xml.search("//a:div", xml.namespaces).first.inner_text
+        assert_equal "hello b", xml.search("//b:div", xml.namespaces).first.inner_text
+        assert_equal "hello c", xml.search("//c:div", xml.namespaces).first.inner_text
+      end
+
+    end
+  end
+end

data/test/xml/test_node_set.rb

@@ -0,0 +1,116 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module XML
+    class TestNodeSet < Nokogiri::TestCase
+      def setup
+        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+      end
+
+      def test_length_size
+        assert node_set = @xml.search('//employee')
+        assert_equal node_set.length, node_set.size
+      end
+
+      def test_at
+        assert node_set = @xml.search('//employee')
+        assert_equal node_set.first, node_set.at(0)
+      end
+
+      def test_push
+        node = Nokogiri::XML::Node.new('foo')
+        node.content = 'bar'
+
+        assert node_set = @xml.search('//employee')
+        node_set.push(node)
+
+        assert node_set.include?(node)
+      end
+
+      def test_unlink
+        xml = Nokogiri::XML.parse(<<-eoxml)
+        <root>
+          <a class='foo bar'>Bar</a>
+          <a class='bar foo'>Bar</a>
+          <a class='bar'>Bar</a>
+          <a>Hello world</a>
+          <a class='baz bar foo'>Bar</a>
+          <a class='bazbarfoo'>Awesome</a>
+          <a class='bazbar'>Awesome</a>
+        </root>
+        eoxml
+        set = xml.xpath('//a')
+        set.unlink
+        set.each do |node|
+          assert !node.parent
+          # assert !node.document # ugh. libxml doesn't clear node->doc pointer, due to xmlDict implementation.
+          assert !node.previous_sibling
+          assert !node.next_sibling
+          assert !node.instance_eval{ owned? }
+        end
+        assert !set.document
+        assert_no_match(/Hello world/, xml.to_s)
+      end
+
+      def test_nodeset_search_takes_namespace
+        @xml = Nokogiri::XML.parse(<<-eoxml)
+<root>
+ <car xmlns:part="http://general-motors.com/">
+  <part:tire>Michelin Model XGV</part:tire>
+ </car>
+ <bicycle xmlns:part="http://schwinn.com/">
+  <part:tire>I'm a bicycle tire!</part:tire>
+ </bicycle>
+</root>
+        eoxml
+        set = @xml/'root'
+        assert_equal 1, set.length
+        bike_tire = set.search('//bike:tire', 'bike' => "http://schwinn.com/")
+        assert_equal 1, bike_tire.length
+      end
+
+      def test_new_nodeset
+        node_set = Nokogiri::XML::NodeSet.new
+        assert_equal(0, node_set.length)
+        node = Nokogiri::XML::Node.new('form')
+        node_set << node
+        assert_equal(1, node_set.length)
+        assert_equal(node, node_set.last)
+      end
+
+      def test_search_on_nodeset
+        assert node_set = @xml.search('//employee')
+        assert sub_set = node_set.search('.//name')
+        assert_equal(node_set.length, sub_set.length)
+      end
+
+      def test_negative_index_works
+        assert node_set = @xml.search('//employee')
+        assert_equal node_set.last, node_set[-1]
+      end
+
+      def test_large_negative_index_returns_nil
+        assert node_set = @xml.search('//employee')
+        assert_nil(node_set[-1 * (node_set.length + 1)])
+      end
+
+      def test_node_set_fetches_private_data
+        assert node_set = @xml.search('//employee')
+
+        set = node_set
+        assert_equal(set[0], set[0])
+      end
+
+      def test_node_set_returns_0
+        assert node_set = @xml.search('//asdkfjhasdlkfjhaldskfh')
+        assert_equal(0, node_set.length)
+      end
+
+      def test_wrap
+        employees = (@xml/"//employee").wrap("<wrapper/>")
+        assert_equal 'wrapper', employees[0].parent.name
+        assert_equal 'employee', @xml.search("//wrapper").first.children[0].name
+      end
+    end
+  end
+end

data/test/xml/test_text.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module XML
+    class TestText < Nokogiri::TestCase
+      def test_new
+        node = Text.new('hello world')
+        assert node
+        assert_equal('hello world', node.content)
+      end
+    end
+  end
+end