gss 0.0.5

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/namespaces/test_namespaces_in_parsed_doc.rb

@@ -0,0 +1,66 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class TestNamespacesInParsedDoc < Nokogiri::TestCase
+      def setup
+        super
+        @doc = Nokogiri::XML <<-eoxml
+          <fruit xmlns="ns:fruit" xmlns:veg="ns:veg" xmlns:xlink="http://www.w3.org/1999/xlink">
+              <pear>
+                  <bosc/>
+              </pear>
+              <orange/>
+              <veg:carrot>
+                  <cheese xmlns="ns:dairy" xlink:href="http://example.com/cheese/"/>
+              </veg:carrot>
+              <meat:bacon xmlns:meat="ns:meat">
+                  <apple count="2"/>
+                  <veg:tomato/>
+              </meat:bacon>
+          </fruit>
+        eoxml
+      end
+
+      def check_namespace e
+        e.namespace.nil? ? nil : e.namespace.href
+      end
+
+      def test_parsed_default_ns
+        assert_equal 'ns:fruit', check_namespace(@doc.root)
+      end
+      def test_parsed_parent_default_ns
+        assert_equal 'ns:fruit', check_namespace(@doc.root.elements[0])
+        assert_equal 'ns:fruit', check_namespace(@doc.root.elements[1])
+      end
+      def test_parsed_grandparent_default_ns
+        assert_equal 'ns:fruit', check_namespace(@doc.root.elements[0].elements[0])
+      end
+      def test_parsed_parent_nondefault_ns
+        assert_equal 'ns:veg',   check_namespace(@doc.root.elements[2])
+      end
+      def test_parsed_single_decl_ns_1
+        assert_equal 'ns:dairy', check_namespace(@doc.root.elements[2].elements[0])
+      end
+      def test_parsed_nondefault_attr_ns
+        assert_equal 'http://www.w3.org/1999/xlink', 
+          check_namespace(@doc.root.elements[2].elements[0].attribute_nodes.find { |a| a.name =~ /href/ })
+      end
+      def test_parsed_single_decl_ns_2
+        assert_equal 'ns:meat',  check_namespace(@doc.root.elements[3])
+      end
+      def test_parsed_buried_default_ns
+        assert_equal 'ns:fruit',  check_namespace(@doc.root.elements[3].elements[0])
+      end
+      def test_parsed_buried_decl_ns
+        assert_equal 'ns:veg',  check_namespace(@doc.root.elements[3].elements[1])
+      end
+      def test_parsed_namespace_count
+        n = @doc.root.clone
+        n.children.each(&:remove)
+        ns_attrs = n.to_xml.scan(/\bxmlns(?::.+?)?=/)
+        assert_equal 3, ns_attrs.length
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/namespaces/test_namespaces_preservation.rb

@@ -0,0 +1,31 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class TestNamespacePreservation < Nokogiri::TestCase
+
+      def setup
+        @xml = Nokogiri.XML <<-eoxml
+              <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element xmlns:quer="http://api.geotrust.com/webtrust/query"/>
+                <xs:element xmlns:quer="http://api.geotrust.com/webtrust/query"/>
+              </xs:schema>
+            eoxml
+      end
+
+      def test_xpath   
+        first = @xml.at_xpath('//xs:element', 'xs' => 'http://www.w3.org/2001/XMLSchema')
+        last = @xml.at_xpath('//xs:element[last()]', 'xs' => 'http://www.w3.org/2001/XMLSchema')
+        assert_equal 'http://api.geotrust.com/webtrust/query' , first.namespaces['xmlns:quer'], "Should contain quer namespace"
+        assert_equal 'http://api.geotrust.com/webtrust/query' , last.namespaces['xmlns:quer'], "Should contain quer namespace"
+      end
+
+      def test_traversing   
+        first = @xml.root.element_children.first
+        last = @xml.root.element_children.last
+        assert_equal 'http://api.geotrust.com/webtrust/query' , first.namespaces['xmlns:quer'], "Should contain quer namespace"
+        assert_equal 'http://api.geotrust.com/webtrust/query' , last.namespaces['xmlns:quer'], "Should contain quer namespace"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/test_convert_xpath.rb

@@ -0,0 +1,135 @@
+require "helper"
+
+class TestConvertXPath < Nokogiri::TestCase
+
+  def setup
+    super
+    @N = Nokogiri(File.read(HTML_FILE))
+  end
+
+  def assert_syntactical_equivalence(hpath, xpath, match, &blk)
+    blk ||= lambda {|j| j.first}
+    assert_equal match, blk.call(@N.search(xpath)), "xpath result did not match"
+  end
+
+  def test_child_tag
+    assert_syntactical_equivalence("h1[a]", ".//h1[child::a]", "Tender Lovemaking") do |j|
+      j.inner_text
+    end
+  end
+
+  def test_child_tag_equals
+    assert_syntactical_equivalence("h1[a='Tender Lovemaking']", ".//h1[child::a = 'Tender Lovemaking']", "Tender Lovemaking") do |j|
+      j.inner_text
+    end
+  end
+
+  def test_filter_contains
+    assert_syntactical_equivalence("title:contains('Tender')", ".//title[contains(., 'Tender')]",
+                                   "Tender Lovemaking  ") do |j|
+      j.inner_text
+    end
+  end
+
+  def test_filter_comment
+    assert_syntactical_equivalence("div comment()[2]", ".//div//comment()[position() = 2]", "<!-- end of header -->") do |j|
+      j.first.to_s
+    end
+  end
+
+  def test_filter_text
+    assert_syntactical_equivalence("a[text()]", ".//a[normalize-space(child::text())]", "<a href=\"http://tenderlovemaking.com\">Tender Lovemaking</a>") do |j|
+      j.first.to_s
+    end
+    assert_syntactical_equivalence("a[text()='Tender Lovemaking']", ".//a[normalize-space(child::text()) = 'Tender Lovemaking']", "<a href=\"http://tenderlovemaking.com\">Tender Lovemaking</a>") do |j|
+      j.first.to_s
+    end
+    assert_syntactical_equivalence("a/text()", ".//a/child::text()", "Tender Lovemaking") do |j|
+      j.first.to_s
+    end
+    assert_syntactical_equivalence("h2//a[text()!='Back Home!']", ".//h2//a[normalize-space(child::text()) != 'Back Home!']", "Meow meow meow meow meow") do |j|
+      j.first.inner_text
+    end
+  end
+
+  def test_filter_by_attr
+    assert_syntactical_equivalence("a[@href='http://blog.geminigeek.com/wordpress-theme']",
+                                   ".//a[@href = 'http://blog.geminigeek.com/wordpress-theme']",
+                                   "http://blog.geminigeek.com/wordpress-theme") do |j|
+      j.first["href"]
+    end
+  end
+
+  def test_css_id
+    assert_syntactical_equivalence("#linkcat-7", ".//*[@id = 'linkcat-7']", "linkcat-7") do |j|
+      j.first["id"]
+    end
+    assert_syntactical_equivalence("li#linkcat-7", ".//li[@id = 'linkcat-7']", "linkcat-7") do |j|
+      j.first["id"]
+    end
+  end
+
+  def test_css_class
+    assert_syntactical_equivalence(".cat-item-15", ".//*[contains(concat(' ', @class, ' '), ' cat-item-15 ')]",
+                                   "cat-item cat-item-15") do |j|
+      j.first["class"]
+    end
+    assert_syntactical_equivalence("li.cat-item-15", ".//li[contains(concat(' ', @class, ' '), ' cat-item-15 ')]",
+                                   "cat-item cat-item-15") do |j|
+      j.first["class"]
+    end
+  end
+
+  def test_css_tags
+    assert_syntactical_equivalence("div li a", ".//div//li//a", "http://brobinius.org/") do |j|
+      j.first.inner_text
+    end
+    assert_syntactical_equivalence("div li > a", ".//div//li/a", "http://brobinius.org/") do |j|
+      j.first.inner_text
+    end
+    assert_syntactical_equivalence("h1 ~ small", ".//small[preceding-sibling::h1]", "The act of making love, tenderly.") do |j|
+      j.first.inner_text
+    end
+    assert_syntactical_equivalence("h1 ~ small", ".//small[preceding-sibling::h1]", "The act of making love, tenderly.") do |j|
+      j.first.inner_text
+    end
+  end
+
+  def test_positional
+    assert_syntactical_equivalence("div/div:first()", ".//div/div[position() = 1]", "\r\nTender Lovemaking\r\nThe act of making love, tenderly.\r\n".gsub(/[\r\n]/, '')) do |j|
+      j.first.inner_text.gsub(/[\r\n]/, '')
+    end
+    assert_syntactical_equivalence("div/div:first", ".//div/div[position() = 1]", "\r\nTender Lovemaking\r\nThe act of making love, tenderly.\r\n".gsub(/[\r\n]/, '')) do |j|
+      j.first.inner_text.gsub(/[\r\n]/, '')
+    end
+    assert_syntactical_equivalence("div//a:last()", ".//div//a[position() = last()]", "Wordpress") do |j|
+      j.last.inner_text
+    end
+    assert_syntactical_equivalence("div//a:last", ".//div//a[position() = last()]", "Wordpress") do |j|
+      j.last.inner_text
+    end
+  end
+
+  def test_multiple_filters
+    assert_syntactical_equivalence("a[@rel='bookmark'][1]", ".//a[@rel = 'bookmark' and position() = 1]", "Back Home!") do |j|
+      j.first.inner_text
+    end
+  end
+
+# TODO:
+#       doc/'title ~ link' -> links that are siblings of title
+#       doc/'p[@class~="final"]' -> class includes string (whitespacy)
+#       doc/'p[text()*="final"]' -> class includes string (index) (broken: always returns true?)
+#       doc/'p[text()$="final"]' -> /final$/
+#       doc/'p[text()|="final"]' -> /^final$/
+#       doc/'p[text()^="final"]' -> string starts with 'final
+#       nth_first
+#       nth_last
+#       even
+#       odd
+#       first-child, nth-child, last-child, nth-last-child, nth-last-of-type
+#       only-of-type, only-child
+#       parent
+#       empty
+#       root
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/test_css_cache.rb

@@ -0,0 +1,45 @@
+require "helper"
+
+class TestCssCache < Nokogiri::TestCase
+
+  def setup
+    super
+    @css = "a1 > b2 > c3"
+    @parse_result = Nokogiri::CSS.parse(@css)
+    @to_xpath_result = @parse_result.map {|ast| ast.to_xpath}
+    Nokogiri::CSS::Parser.class_eval do
+      class << @cache
+        alias :old_bracket :[]
+        attr_reader :count
+        def [](key)
+          @count ||= 0
+          @count += 1
+          old_bracket(key)
+        end
+      end
+    end
+    assert Nokogiri::CSS::Parser.cache_on?
+  end
+
+  def teardown
+    Nokogiri::CSS::Parser.clear_cache
+    Nokogiri::CSS::Parser.set_cache true
+  end
+
+  [ false, true ].each do |cache_setting|
+    define_method "test_css_cache_#{cache_setting ? "true" : "false"}" do
+      times = cache_setting ? 4 : nil
+
+      Nokogiri::CSS::Parser.set_cache cache_setting
+
+      Nokogiri::CSS.xpath_for(@css)
+      Nokogiri::CSS.xpath_for(@css)
+      Nokogiri::CSS::Parser.new.xpath_for(@css)
+      Nokogiri::CSS::Parser.new.xpath_for(@css)
+
+      assert_equal(times, Nokogiri::CSS::Parser.class_eval { @cache.count })
+    end
+  end
+
+
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/test_encoding_handler.rb

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+
+require "helper"
+
+class TestEncodingHandler < Nokogiri::TestCase
+  def teardown
+    Nokogiri::EncodingHandler.clear_aliases!
+  end
+
+  def test_get
+    assert_not_nil Nokogiri::EncodingHandler['UTF-8']
+    assert_nil Nokogiri::EncodingHandler['alsdkjfhaldskjfh']
+  end
+
+  def test_name
+    eh = Nokogiri::EncodingHandler['UTF-8']
+    assert_equal "UTF-8", eh.name
+  end
+
+  def test_alias
+    Nokogiri::EncodingHandler.alias('UTF-8', 'UTF-18')
+    assert_equal 'UTF-8', Nokogiri::EncodingHandler['UTF-18'].name
+  end
+
+  def test_cleanup_aliases
+    assert_nil Nokogiri::EncodingHandler['UTF-9']
+    Nokogiri::EncodingHandler.alias('UTF-8', 'UTF-9')
+    assert_not_nil Nokogiri::EncodingHandler['UTF-9']
+
+    Nokogiri::EncodingHandler.clear_aliases!
+    assert_nil Nokogiri::EncodingHandler['UTF-9']
+  end
+
+  def test_delete
+    assert_nil Nokogiri::EncodingHandler['UTF-9']
+    Nokogiri::EncodingHandler.alias('UTF-8', 'UTF-9')
+    assert_not_nil Nokogiri::EncodingHandler['UTF-9']
+
+    Nokogiri::EncodingHandler.delete 'UTF-9'
+    assert_nil Nokogiri::EncodingHandler['UTF-9']
+  end
+
+  def test_delete_non_existent
+    assert_nil Nokogiri::EncodingHandler.delete('UTF-9')
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/test_memory_leak.rb

@@ -0,0 +1,156 @@
+require "helper"
+
+class TestMemoryLeak < Nokogiri::TestCase
+  def setup
+    super
+    @str = <<EOF
+<!DOCTYPE HTML>
+<html>
+  <body>
+    <br />
+  </body>
+</html>
+EOF
+  end
+
+  if ENV['NOKOGIRI_GC'] # turning these off by default for now
+    def test_dont_hurt_em_why
+      content = File.open("#{File.dirname(__FILE__)}/files/dont_hurt_em_why.xml").read
+      ndoc = Nokogiri::XML(content)
+      2.times do
+        ndoc.search('status text').first.inner_text
+        ndoc.search('user name').first.inner_text
+        GC.start
+      end
+    end
+
+    class BadIO
+      def read(*args)
+        raise 'hell'
+      end
+
+      def write(*args)
+        raise 'chickens'
+      end
+    end
+
+    def test_for_mem_leak_on_io_callbacks
+      io = File.open SNUGGLES_FILE
+      Nokogiri::XML.parse(io)
+
+      loop do
+        Nokogiri::XML.parse(BadIO.new) rescue nil
+        doc.write BadIO.new rescue nil
+      end
+    end
+
+    def test_for_memory_leak
+      begin
+        #  we don't use Dike in any tests, but requiring it has side effects
+        #  that can create memory leaks, and that's what we're testing for.
+        require 'rubygems'
+        require 'dike' # do not remove!
+
+        count_start = count_object_space_documents
+        xml_data = <<-EOS
+        <test>
+          <items>
+            <item>abc</item>
+            <item>1234</item>
+            <item>Zzz</item>
+          <items>
+        </test>
+        EOS
+        20.times do
+          doc = Nokogiri::XML(xml_data)
+          doc.xpath("//item")
+        end
+        2.times { GC.start }
+        count_end = count_object_space_documents
+        assert((count_end - count_start) <= 2, "memory leak detected")
+      rescue LoadError
+        puts "\ndike is not installed, skipping memory leak test"
+      end
+    end
+
+    def test_node_set_namespace_mem_leak
+      xml = Nokogiri::XML "<foo></foo>"
+      ctx = Nokogiri::XML::XPathContext.new(xml)
+      loop do
+        ctx.evaluate("//namespace::*")
+      end
+    end
+
+    def test_leak_on_node_replace
+      loop do
+        doc = Nokogiri.XML("<root><foo /></root>")
+        n = Nokogiri::XML::CDATA.new(doc, "bar")
+        pivot = doc.root.children[0]
+        pivot.replace(n)
+      end
+    end
+
+    def test_sax_parser_context
+      io = StringIO.new(@str)
+
+      loop do
+        Nokogiri::XML::SAX::ParserContext.new(@str)
+        Nokogiri::XML::SAX::ParserContext.new(io)
+        io.rewind
+
+        Nokogiri::HTML::SAX::ParserContext.new(@str)
+        Nokogiri::HTML::SAX::ParserContext.new(io)
+        io.rewind
+      end
+    end
+
+    class JumpingSaxHandler < Nokogiri::XML::SAX::Document
+      def initialize(jumptag)
+        @jumptag = jumptag
+        super()
+      end
+
+      def start_element(name, attrs = [])
+        throw @jumptag
+      end
+    end
+
+    def test_jumping_sax_handler
+      doc = JumpingSaxHandler.new(:foo)
+
+      loop do
+        catch(:foo) do
+          Nokogiri::HTML::SAX::Parser.new(doc).parse(@str)
+        end
+      end
+    end
+
+    def test_in_context_parser_leak
+      loop do 
+        doc = Nokogiri::XML::Document.new
+        fragment1 = Nokogiri::XML::DocumentFragment.new(doc, '<foo/>')
+        node = fragment1.children[0]
+        node.parse('<bar></bar>')
+      end
+    end
+
+    def test_in_context_parser_leak_ii
+      loop { Nokogiri::XML('<a/>').root.parse('<b/>') }
+    end
+
+    def test_leak_on_xpath_string_function
+      doc = Nokogiri::XML(@str)
+      loop do
+        doc.xpath('name(//node())')
+      end
+    end
+  end # if NOKOGIRI_GC
+
+  private
+
+  def count_object_space_documents
+    count = 0
+    ObjectSpace.each_object {|j| count += 1 if j.is_a?(Nokogiri::XML::Document) }
+    count
+  end
+end