nokogiri 1.2.3 → 1.3.0

data/test/xml/test_node_attributes.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module XML
+    class TestNodeAttributes < Nokogiri::TestCase
+      def test_attribute_with_ns
+        doc = Nokogiri::XML <<-eoxml
+          <root xmlns:tlm='http://tenderlovemaking.com/'>
+            <node tlm:foo='bar' foo='baz' />
+          </root>
+        eoxml
+
+        node = doc.at('node')
+
+        assert_equal 'bar',
+          node.attribute_with_ns('foo', 'http://tenderlovemaking.com/').value
+      end
+
+      def test_namespace_key?
+        doc = Nokogiri::XML <<-eoxml
+          <root xmlns:tlm='http://tenderlovemaking.com/'>
+            <node tlm:foo='bar' foo='baz' />
+          </root>
+        eoxml
+
+        node = doc.at('node')
+
+        assert node.namespaced_key?('foo', 'http://tenderlovemaking.com/')
+        assert node.namespaced_key?('foo', nil)
+        assert !node.namespaced_key?('foo', 'foo')
+      end
+    end
+  end
+end

data/test/xml/test_node_encoding.rb

@@ -49,7 +49,8 @@ module Nokogiri
           assert_equal 'UTF-8', doc.encoding
           n = doc.xpath('//part:tire', { 'part' => 'http://schwinn.com/' }).first
           assert n
-          assert_equal doc.encoding, n.namespace.encoding.name
+          assert_equal doc.encoding, n.namespace.href.encoding.name
+          assert_equal doc.encoding, n.namespace.prefix.encoding.name
         end
 
         def test_namespace_as_hash
@@ -66,9 +67,15 @@ module Nokogiri
           doc = Nokogiri::XML(xml, nil, 'UTF-8')
           assert_equal 'UTF-8', doc.encoding
           assert n = doc.xpath('//car').first
+
+          n.namespace_definitions.each do |nd|
+            assert_equal doc.encoding, nd.href.encoding.name
+            assert_equal doc.encoding, nd.prefix.encoding.name
+          end
+
           n.namespaces.each do |k,v|
-            assert_equal doc.encoding, v.encoding.name
             assert_equal doc.encoding, k.encoding.name
+            assert_equal doc.encoding, v.encoding.name
           end
         end
       end

data/test/xml/test_node_set.rb

@@ -5,7 +5,63 @@ module Nokogiri
     class TestNodeSet < Nokogiri::TestCase
       def setup
         super
-        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+        @xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE)
+      end
+
+      def test_double_equal
+        assert node_set_one = @xml.xpath('//employee')
+        assert node_set_two = @xml.xpath('//employee')
+
+        assert_not_equal node_set_one.object_id, node_set_two.object_id
+
+        assert_equal node_set_one, node_set_two
+      end
+
+      def test_node_set_not_equal_to_string
+        node_set_one = @xml.xpath('//employee')
+        assert_not_equal node_set_one, "asdfadsf"
+      end
+
+      def test_out_of_order_not_equal
+        one = @xml.xpath('//employee')
+        two = @xml.xpath('//employee')
+        two.push two.shift
+        assert_not_equal one, two
+      end
+
+      def test_shorter_is_not_equal
+        node_set_one = @xml.xpath('//employee')
+        node_set_two = @xml.xpath('//employee')
+        node_set_two.delete(node_set_two.first)
+
+        assert_not_equal node_set_one, node_set_two
+      end
+
+      def test_pop
+        set = @xml.xpath('//employee')
+        last = set.last
+        assert_equal last, set.pop
+      end
+
+      def test_shift
+        set = @xml.xpath('//employee')
+        first = set.first
+        assert_equal first, set.shift
+      end
+
+      def test_shift_empty
+        set = Nokogiri::XML::NodeSet.new(@xml)
+        assert_nil set.shift
+      end
+
+      def test_pop_empty
+        set = Nokogiri::XML::NodeSet.new(@xml)
+        assert_nil set.pop
+      end
+
+      def test_first_takes_arguments
+        assert node_set = @xml.xpath('//employee')
+        assert_equal 2, node_set.first(2).length
       end
 
       def test_dup
@@ -36,6 +92,12 @@ module Nokogiri
         assert set.at('bar')
       end
 
+      def test_children_has_document
+        set = @xml.root.children
+        assert_instance_of(NodeSet, set)
+        assert_equal @xml, set.document
+      end
+
       def test_length_size
         assert node_set = @xml.search('//employee')
         assert_equal node_set.length, node_set.size
@@ -67,6 +129,11 @@ module Nokogiri
         assert node_set = @xml.search('//employee')
         assert_equal node_set.first, node_set.at(0)
       end
+      
+      def test_percent
+        assert node_set = @xml.search('//employee')
+        assert_equal node_set.first, node_set % 0
+      end
 
       def test_to_ary
         assert node_set = @xml.search('//employee')
@@ -85,6 +152,36 @@ module Nokogiri
         assert node_set.include?(node)
       end
 
+      def test_delete_with_invalid_argument
+        employees = @xml.search("//employee")
+        positions = @xml.search("//position")
+
+        assert_raises(ArgumentError) { employees.delete(positions) }
+      end
+
+      def test_delete_when_present
+        employees = @xml.search("//employee")
+        wally = employees.first
+        assert employees.include?(wally) # testing setup
+        length = employees.length
+
+        result = employees.delete(wally)
+        assert_equal result, wally
+        assert ! employees.include?(wally)
+        assert length-1, employees.length
+      end
+
+      def test_delete_when_not_present
+        employees = @xml.search("//employee")
+        phb = @xml.search("//position").first
+        assert ! employees.include?(phb) # testing setup
+        length = employees.length
+
+        result = employees.delete(phb)
+        assert_nil result
+        assert length, employees.length
+      end
+
       def test_unlink
         xml = Nokogiri::XML.parse(<<-eoxml)
         <root>
@@ -167,6 +264,105 @@ module Nokogiri
         assert_equal 'wrapper', employees[0].parent.name
         assert_equal 'employee', @xml.search("//wrapper").first.children[0].name
       end
+
+      def test_plus_operator
+        names = @xml.search("name")
+        positions = @xml.search("position")
+
+        names_len = names.length
+        positions_len = positions.length
+
+        assert_raises(ArgumentError) { result = names + positions.first }
+
+        result = names + positions
+        assert_equal names_len,                         names.length
+        assert_equal positions_len,                     positions.length
+        assert_equal names.length + positions.length,   result.length
+
+        names += positions
+        assert_equal result.length, names.length
+      end
+
+      def test_minus_operator
+        employees = @xml.search("//employee")
+        females = @xml.search("//employee[gender[text()='Female']]")
+
+        employees_len = employees.length
+        females_len = females.length
+
+        assert_raises(ArgumentError) { result = employees - females.first }
+
+        result = employees - females
+        assert_equal employees_len,                     employees.length
+        assert_equal females_len,                       females.length
+        assert_equal employees.length - females.length, result.length
+
+        employees -= females
+        assert_equal result.length, employees.length
+      end
+
+      def test_array_index
+        employees = @xml.search("//employee")
+        other = @xml.search("//position").first
+
+        assert_equal 3, employees.index(employees[3])
+        assert_nil employees.index(other)
+      end
+
+      def test_array_slice_with_start_and_end
+        employees = @xml.search("//employee")
+        assert_equal [employees[1], employees[2], employees[3]], employees[1,3].to_a
+      end
+
+      def test_array_index_bracket_equivalence
+        employees = @xml.search("//employee")
+        assert_equal [employees[1], employees[2], employees[3]], employees[1,3].to_a
+        assert_equal [employees[1], employees[2], employees[3]], employees.slice(1,3).to_a
+      end
+
+      def test_array_slice_with_negative_start
+        employees = @xml.search("//employee")
+        assert_equal [employees[2]],                    employees[-3,1].to_a
+        assert_equal [employees[2], employees[3]],      employees[-3,2].to_a
+      end
+
+      def test_array_slice_with_invalid_args
+        employees = @xml.search("//employee")
+        assert_nil employees[99, 1] # large start
+        assert_nil employees[1, -1] # negative len
+        assert_equal [], employees[1, 0].to_a # zero len
+      end
+
+      def test_array_slice_with_range
+        employees = @xml.search("//employee")
+        assert_equal [employees[1], employees[2], employees[3]], employees[1..3].to_a
+        assert_equal [employees[0], employees[1], employees[2], employees[3]], employees[0..3].to_a
+      end
+
+      def test_intersection_with_no_overlap
+        employees = @xml.search("//employee")
+        positions = @xml.search("//position")
+
+        assert_equal [], (employees & positions).to_a
+      end
+
+      def test_intersection
+        employees = @xml.search("//employee")
+        first_set = employees[0..2]
+        second_set = employees[2..4]
+
+        assert_equal [employees[2]], (first_set & second_set).to_a
+      end
+
+      def test_include?
+        employees = @xml.search("//employee")
+        yes = employees.first
+        no = @xml.search("//position").first
+
+        assert employees.include?(yes)
+        assert ! employees.include?(no)
+      end
+
     end
   end
 end

data/test/xml/test_parse_options.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module XML
+    class TestParseOptions < Nokogiri::TestCase
+      def test_new
+        options = Nokogiri::XML::ParseOptions.new
+        assert_equal 0, options.options
+      end
+
+      def test_to_i
+        options = Nokogiri::XML::ParseOptions.new
+        assert_equal 0, options.to_i
+      end
+
+      ParseOptions.constants.each do |constant|
+        next if constant == 'STRICT'
+        class_eval %{
+          def test_predicate_#{constant.downcase}
+            options = ParseOptions.new(ParseOptions::#{constant})
+            assert options.#{constant.downcase}?
+
+            assert ParseOptions.new.#{constant.downcase}.#{constant.downcase}?
+          end
+        }
+      end
+
+      def test_strict_noent
+        options = ParseOptions.new.recover.noent
+        assert !options.strict?
+      end
+
+      def test_new_with_argument
+        options = Nokogiri::XML::ParseOptions.new 1 << 1
+        assert_equal 1 << 1, options.options
+      end
+
+      def test_chaining
+        options = Nokogiri::XML::ParseOptions.new.recover.noent
+        assert options.recover?
+        assert options.noent?
+      end
+
+      def test_inspect
+        options = Nokogiri::XML::ParseOptions.new.recover.noent
+        ins = options.inspect
+        assert_match(/recover/, ins)
+        assert_match(/noent/, ins)
+      end
+    end
+  end
+end

data/test/xml/test_processing_instruction.rb

@@ -20,6 +20,11 @@ module Nokogiri
         assert ref = ProcessingInstruction.new(@xml, 'name', 'content')
         assert_instance_of ProcessingInstruction, ref
       end
+
+      def test_many_new
+        100.times { ProcessingInstruction.new(@xml, 'foo', 'bar') }
+        @xml.root << ProcessingInstruction.new(@xml, 'foo', 'bar')
+      end
     end
   end
 end

data/test/xml/test_relax_ng.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module XML
+    class TestRelaxNG < Nokogiri::TestCase
+      def setup
+        assert @schema = Nokogiri::XML::RelaxNG(File.read(ADDRESS_SCHEMA_FILE))
+      end
+
+      def test_parse_with_memory
+        assert_instance_of Nokogiri::XML::RelaxNG, @schema
+        assert_equal 0, @schema.errors.length
+      end
+
+      def test_new
+        assert schema = Nokogiri::XML::RelaxNG.new(
+          File.read(ADDRESS_SCHEMA_FILE))
+        assert_instance_of Nokogiri::XML::RelaxNG, schema
+      end
+
+      def test_parse_with_io
+        xsd = nil
+        File.open(ADDRESS_SCHEMA_FILE, 'rb') { |f|
+          assert xsd = Nokogiri::XML::RelaxNG(f)
+        }
+        assert_equal 0, xsd.errors.length
+      end
+
+      def test_parse_with_errors
+        xml = File.read(ADDRESS_SCHEMA_FILE).sub(/name="/, 'name=')
+        assert_raises(Nokogiri::XML::SyntaxError) {
+          Nokogiri::XML::RelaxNG(xml)
+        }
+      end
+
+      def test_validate_document
+        doc = Nokogiri::XML(File.read(ADDRESS_XML_FILE))
+        assert errors = @schema.validate(doc)
+        assert_equal 0, errors.length
+      end
+
+      def test_validate_invalid_document
+        # Empty address book is not allowed
+        read_doc = '<addressBook></addressBook>'
+
+        assert errors = @schema.validate(Nokogiri::XML(read_doc))
+        assert_equal 1, errors.length
+      end
+
+      def test_valid?
+        valid_doc = Nokogiri::XML(File.read(ADDRESS_XML_FILE))
+
+        invalid_doc = Nokogiri::XML('<addressBook></addressBook>')
+
+        assert(@schema.valid?(valid_doc))
+        assert(!@schema.valid?(invalid_doc))
+      end
+    end
+  end
+end

data/test/xml/test_schema.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "helper"))
+
+module Nokogiri
+  module XML
+    class TestSchema < Nokogiri::TestCase
+      def setup
+        assert @xsd = Nokogiri::XML::Schema(File.read(PO_SCHEMA_FILE))
+      end
+
+      def test_parse_with_memory
+        assert_instance_of Nokogiri::XML::Schema, @xsd
+        assert_equal 0, @xsd.errors.length
+      end
+
+      def test_new
+        assert xsd = Nokogiri::XML::Schema.new(File.read(PO_SCHEMA_FILE))
+        assert_instance_of Nokogiri::XML::Schema, xsd
+      end
+
+      def test_parse_with_io
+        xsd = nil
+        File.open(PO_SCHEMA_FILE, 'rb') { |f|
+          assert xsd = Nokogiri::XML::Schema(f)
+        }
+        assert_equal 0, xsd.errors.length
+      end
+
+      def test_parse_with_errors
+        xml = File.read(PO_SCHEMA_FILE).sub(/name="/, 'name=')
+        assert_raises(Nokogiri::XML::SyntaxError) {
+          Nokogiri::XML::Schema(xml)
+        }
+      end
+
+      def test_validate_document
+        doc = Nokogiri::XML(File.read(PO_XML_FILE))
+        assert errors = @xsd.validate(doc)
+        assert_equal 0, errors.length
+      end
+
+      def test_validate_file
+        assert errors = @xsd.validate(PO_XML_FILE)
+        assert_equal 0, errors.length
+      end
+
+      def test_validate_invalid_document
+        read_doc = File.read(PO_XML_FILE).gsub(/<city>[^<]*<\/city>/, '')
+
+        assert errors = @xsd.validate(Nokogiri::XML(read_doc))
+        assert_equal 2, errors.length
+      end
+
+      def test_valid?
+        valid_doc = Nokogiri::XML(File.read(PO_XML_FILE))
+
+        invalid_doc = Nokogiri::XML(
+          File.read(PO_XML_FILE).gsub(/<city>[^<]*<\/city>/, '')
+        )
+
+        assert(@xsd.valid?(valid_doc))
+        assert(!@xsd.valid?(invalid_doc))
+      end
+    end
+  end
+end