RubyGems - iisconfig - Versions diffs - 0.0.1.pre2 → 0.0.1.pre3 - Mend

iisconfig 0.0.1.pre2 → 0.0.1.pre3

Files changed (655) hide show

data/build/bundler/ruby/1.9.1/gems/nokogiri-1.5.0-x86-mingw32/test/html/test_document_fragment.rb DELETED Viewed

@@ -1,255 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-module Nokogiri
-  module HTML
-    class TestDocumentFragment < Nokogiri::TestCase
-      def setup
-        super
-        @html = Nokogiri::HTML.parse(File.read(HTML_FILE), HTML_FILE)
-      end
-      if RUBY_VERSION >= '1.9'
-        def test_inspect_encoding
-          fragment = "<div>こんにちは！</div>".encode('EUC-JP')
-          f = Nokogiri::HTML::DocumentFragment.parse fragment
-          assert_equal "こんにちは！", f.content
-        end
-        def test_html_parse_encoding
-          fragment = "<div>こんにちは！</div>".encode 'EUC-JP'
-          f = Nokogiri::HTML.fragment fragment
-          assert_equal 'EUC-JP', f.document.encoding
-          assert_equal "こんにちは！", f.content
-        end
-      end
-      def test_parse_encoding
-        fragment = "<div>hello world</div>"
-        f = Nokogiri::HTML::DocumentFragment.parse fragment, 'ISO-8859-1'
-        assert_equal 'ISO-8859-1', f.document.encoding
-        assert_equal "hello world", f.content
-      end
-      def test_html_parse_with_encoding
-        fragment = "<div>hello world</div>"
-        f = Nokogiri::HTML.fragment fragment, 'ISO-8859-1'
-        assert_equal 'ISO-8859-1', f.document.encoding
-        assert_equal "hello world", f.content
-      end
-      def test_parse_in_context
-        assert_equal('<br>', @html.root.parse('<br />').to_s)
-      end
-      def test_inner_html=
-        fragment = Nokogiri::HTML.fragment '<hr />'
-        fragment.inner_html = "hello"
-        assert_equal 'hello', fragment.inner_html
-      end
-      def test_ancestors_search
-        html = %q{
-          <div>
-            <ul>
-              <li>foo</li>
-            </ul>
-          </div>
-        }
-        fragment = Nokogiri::HTML.fragment html
-        li = fragment.at('li')
-        assert li.matches?('li')
-      end
-      def test_fun_encoding
-        string = %Q(<body>こんにちは</body>)
-        html = Nokogiri::HTML::DocumentFragment.parse(
-          string
-        ).to_html(:encoding => 'UTF-8')
-        assert_equal string, html
-      end
-      def test_new
-        assert Nokogiri::HTML::DocumentFragment.new(@html)
-      end
-      def test_body_fragment_should_contain_body
-        fragment = Nokogiri::HTML::DocumentFragment.parse("  <body><div>foo</div></body>")
-        assert_match(/^<body>/, fragment.to_s)
-      end
-      def test_nonbody_fragment_should_not_contain_body
-        fragment = Nokogiri::HTML::DocumentFragment.parse("<div>foo</div>")
-        assert_match(/^<div>/, fragment.to_s)
-      end
-      def test_fragment_should_have_document
-        fragment = Nokogiri::HTML::DocumentFragment.new(@html)
-        assert_equal @html, fragment.document
-      end
-      def test_empty_fragment_should_be_searchable_by_css
-        fragment = Nokogiri::HTML.fragment("")
-        assert_equal 0, fragment.css("a").size
-      end
-      def test_empty_fragment_should_be_searchable
-        fragment = Nokogiri::HTML.fragment("")
-        assert_equal 0, fragment.search("//a").size
-      end
-      def test_name
-        fragment = Nokogiri::HTML::DocumentFragment.new(@html)
-        assert_equal '#document-fragment', fragment.name
-      end
-      def test_static_method
-        fragment = Nokogiri::HTML::DocumentFragment.parse("<div>a</div>")
-        assert_instance_of Nokogiri::HTML::DocumentFragment, fragment
-      end
-      def test_many_fragments
-        100.times { Nokogiri::HTML::DocumentFragment.new(@html) }
-      end
-      def test_subclass
-        klass = Class.new(Nokogiri::HTML::DocumentFragment)
-        fragment = klass.new(@html, "<div>a</div>")
-        assert_instance_of klass, fragment
-      end
-      def test_subclass_parse
-        klass = Class.new(Nokogiri::HTML::DocumentFragment)
-        doc = klass.parse("<div>a</div>")
-        assert_instance_of klass, doc
-      end
-      def test_html_fragment
-        fragment = Nokogiri::HTML.fragment("<div>a</div>")
-        assert_equal "<div>a</div>", fragment.to_s
-      end
-      def test_html_fragment_has_outer_text
-        doc = "a<div>b</div>c"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        if Nokogiri.uses_libxml? &&
-            Nokogiri::VERSION_INFO['libxml']['loaded'] <= "2.6.16"
-          assert_equal "a<div>b</div><p>c</p>", fragment.to_s
-        else
-          assert_equal "a<div>b</div>c", fragment.to_s
-        end
-      end
-      def test_html_fragment_case_insensitivity
-        doc = "<Div>b</Div>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_equal "<div>b</div>", fragment.to_s
-      end
-      def test_html_fragment_with_leading_whitespace
-        doc = "     <div>b</div>  "
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_match %r%     <div>b</div> *%, fragment.to_s
-      end
-      def test_html_fragment_with_leading_whitespace_and_newline
-        doc = "     \n<div>b</div>  "
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_match %r%     \n<div>b</div> *%, fragment.to_s
-      end
-      def test_html_fragment_with_leading_text_and_newline
-        fragment = HTML::Document.new.fragment("First line\nSecond line<br>Broken line")
-        assert_equal fragment.to_s, "First line\nSecond line<br>Broken line"
-      end
-      def test_html_fragment_with_leading_whitespace_and_text_and_newline
-        fragment = HTML::Document.new.fragment("  First line\nSecond line<br>Broken line")
-        assert_equal "  First line\nSecond line<br>Broken line", fragment.to_s
-      end
-      def test_html_fragment_with_leading_entity
-        failed = "&quot;test<br/>test&quot;"
-        fragment = Nokogiri::HTML::DocumentFragment.parse(failed)
-        assert_equal '"test<br>test"', fragment.to_html
-      end
-      def test_to_s
-        doc = "<span>foo<br></span><span>bar</span>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_equal "<span>foo<br></span><span>bar</span>", fragment.to_s
-      end
-      def test_to_html
-        doc = "<span>foo<br></span><span>bar</span>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_equal "<span>foo<br></span><span>bar</span>", fragment.to_html
-      end
-      def test_to_xhtml
-        doc = "<span>foo<br></span><span>bar</span>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        if !Nokogiri.uses_libxml? ||
-            Nokogiri::VERSION_INFO['libxml']['loaded'] >= "2.7.0"
-          assert_equal "<span>foo<br /></span><span>bar</span>", fragment.to_xhtml
-        else
-          assert_equal "<span>foo<br></span><span>bar</span>", fragment.to_xhtml
-        end
-      end
-      def test_to_xml
-        doc = "<span>foo<br></span><span>bar</span>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_equal "<span>foo<br/></span><span>bar</span>", fragment.to_xml
-      end
-      def test_fragment_script_tag_with_cdata
-        doc = HTML::Document.new
-        fragment = doc.fragment("<script>var foo = 'bar';</script>")
-        assert_equal("<script>var foo = 'bar';</script>",
-          fragment.to_s)
-      end
-      def test_fragment_with_comment
-        doc = HTML::Document.new
-        fragment = doc.fragment("<p>hello<!-- your ad here --></p>")
-        assert_equal("<p>hello<!-- your ad here --></p>",
-          fragment.to_s)
-      end
-      def test_malformed_fragment_is_corrected
-        fragment = HTML::DocumentFragment.parse("<div </div>")
-        assert_equal "<div></div>", fragment.to_s
-      end
-      def test_unclosed_script_tag
-        # see GH#315
-        fragment = HTML::DocumentFragment.parse("foo <script>bar")
-        assert_equal "foo <script>bar</script>", fragment.to_html
-      end
-      def test_error_propagation_on_fragment_parse
-        frag = Nokogiri::HTML::DocumentFragment.parse "<hello>oh, hello there.</hello>"
-        assert frag.errors.any?{|err| err.to_s =~ /Tag hello invalid/}, "errors should be copied to the fragment"
-      end
-      def test_error_propagation_on_fragment_parse_in_node_context
-        doc = Nokogiri::HTML::Document.parse "<html><body><div></div></body></html>"
-        context_node = doc.at_css "div"
-        frag = Nokogiri::HTML::DocumentFragment.new doc, "<hello>oh, hello there.</hello>", context_node
-        assert frag.errors.any?{|err| err.to_s =~ /Tag hello invalid/}, "errors should be on the context node's document"
-      end
-      def test_error_propagation_on_fragment_parse_in_node_context_should_not_include_preexisting_errors
-        doc = Nokogiri::HTML::Document.parse "<html><body><div></div><jimmy></jimmy></body></html>"
-        assert doc.errors.any?{|err| err.to_s =~ /jimmy/}, "assert on setup"
-        context_node = doc.at_css "div"
-        frag = Nokogiri::HTML::DocumentFragment.new doc, "<hello>oh, hello there.</hello>", context_node
-        assert frag.errors.any?{|err| err.to_s =~ /Tag hello invalid/}, "errors should be on the context node's document"
-        assert frag.errors.none?{|err| err.to_s =~ /jimmy/}, "errors should not include pre-existing document errors"
-      end
-    end
-  end
-end

data/build/bundler/ruby/1.9.1/gems/nokogiri-1.5.0-x86-mingw32/test/html/test_element_description.rb DELETED Viewed

@@ -1,100 +0,0 @@
-require "helper"
-module Nokogiri
-  module HTML
-    class TestElementDescription < Nokogiri::TestCase
-      def test_fetch_nonexistent
-        assert_nil ElementDescription['foo']
-      end
-      def test_fetch_element_description
-        assert desc = ElementDescription['a']
-        assert_instance_of ElementDescription, desc
-      end
-      def test_name
-        assert_equal 'a', ElementDescription['a'].name
-      end
-      def test_implied_start_tag?
-        assert !ElementDescription['a'].implied_start_tag?
-      end
-      def test_implied_end_tag?
-        assert !ElementDescription['a'].implied_end_tag?
-        assert ElementDescription['p'].implied_end_tag?
-      end
-      def test_save_end_tag?
-        assert !ElementDescription['a'].save_end_tag?
-        assert ElementDescription['br'].save_end_tag?
-      end
-      def test_empty?
-        assert ElementDescription['br'].empty?
-        assert !ElementDescription['a'].empty?
-      end
-      def test_deprecated?
-        assert ElementDescription['applet'].deprecated?
-        assert !ElementDescription['br'].deprecated?
-      end
-      def test_inline?
-        assert ElementDescription['a'].inline?
-        assert !ElementDescription['div'].inline?
-      end
-      def test_block?
-        element = ElementDescription['a']
-        assert_equal(!element.inline?, element.block?)
-      end
-      def test_description
-        assert ElementDescription['a'].description
-      end
-      def test_subelements
-        sub_elements = ElementDescription['body'].sub_elements
-        if Nokogiri.uses_libxml? && Nokogiri::LIBXML_VERSION >= '2.7.7'
-          assert_equal 65, sub_elements.length
-        elsif Nokogiri.uses_libxml?
-          assert_equal 61, sub_elements.length
-        else
-          assert sub_elements.length > 0
-        end
-      end
-      def test_default_sub_element
-        assert_equal 'div', ElementDescription['body'].default_sub_element
-      end
-      def test_optional_attributes
-        attrs = ElementDescription['table'].optional_attributes
-        assert attrs
-      end
-      def test_deprecated_attributes
-        attrs = ElementDescription['table'].deprecated_attributes
-        assert attrs
-        assert_equal 2, attrs.length
-      end
-      def test_required_attributes
-        attrs = ElementDescription['table'].required_attributes
-        assert attrs
-        assert_equal 0, attrs.length
-      end
-      def test_inspect
-        desc = ElementDescription['input']
-        assert_match desc.name, desc.inspect
-      end
-      def test_to_s
-        desc = ElementDescription['input']
-        assert_match desc.name, desc.to_s
-      end
-    end
-  end
-end

data/build/bundler/ruby/1.9.1/gems/nokogiri-1.5.0-x86-mingw32/test/html/test_named_characters.rb DELETED Viewed

@@ -1,14 +0,0 @@
-require "helper"
-module Nokogiri
-  module HTML
-    class TestNamedCharacters < Nokogiri::TestCase
-      def test_named_character
-        copy = NamedCharacters.get('copy')
-        assert_equal 169, NamedCharacters['copy']
-        assert_equal copy.value, NamedCharacters['copy']
-        assert copy.description
-      end
-    end
-  end
-end

data/build/bundler/ruby/1.9.1/gems/nokogiri-1.5.0-x86-mingw32/test/html/test_node.rb DELETED Viewed

@@ -1,190 +0,0 @@
-require "helper"
-require 'nkf'
-module Nokogiri
-  module HTML
-    class TestNode < Nokogiri::TestCase
-      def setup
-        super
-        @html = Nokogiri::HTML(<<-eohtml)
-        <html>
-          <head></head>
-          <body>
-            <div class='baz'><a href="foo" class="bar">first</a></div>
-          </body>
-        </html>
-        eohtml
-      end
-      def test_to_a
-        assert_equal [['class', 'bar'], ['href', 'foo']],@html.at('a').to_a.sort
-      end
-      def test_attr
-        node = @html.at('div.baz')
-        assert_equal node['class'], node.attr('class')
-      end
-      def test_get_attribute
-        element = @html.at('div')
-        assert_equal 'baz', element.get_attribute('class')
-        assert_equal 'baz', element['class']
-        element['href'] = "javascript:alert(\"AGGA-KA-BOO!\")"
-        assert_match(/%22AGGA-KA-BOO!%22/, element.to_html)
-      end
-      def test_css_path_round_trip
-        doc = Nokogiri::HTML(File.read(HTML_FILE))
-        %w{ #header small div[2] div.post body }.each do |css_sel|
-          ele = doc.at css_sel
-          assert_equal ele, doc.at(ele.css_path), ele.css_path
-        end
-      end
-      def test_path_round_trip
-        doc = Nokogiri::HTML(File.read(HTML_FILE))
-        %w{ #header small div[2] div.post body }.each do |css_sel|
-          ele = doc.at css_sel
-          assert_equal ele, doc.at(ele.path), ele.path
-        end
-      end
-      def test_append_with_document
-        assert_raises(ArgumentError) do
-          @html.root << Nokogiri::HTML::Document.new
-        end
-      end
-      ###
-      # Make sure a document that doesn't declare a meta encoding returns
-      # nil.
-      def test_meta_encoding
-        assert_nil @html.meta_encoding
-      end
-      def test_description
-        assert desc = @html.at('a.bar').description
-        assert_equal 'a', desc.name
-      end
-      def test_ancestors_with_selector
-        assert node = @html.at('a.bar').child
-        assert list = node.ancestors('.baz')
-        assert_equal 1, list.length
-        assert_equal 'div', list.first.name
-      end
-      def test_matches_inside_fragment
-        fragment = DocumentFragment.new @html
-        fragment << XML::Node.new('a', @html)
-        a = fragment.children.last
-        assert a.matches?('a'), 'a should match'
-      end
-      def test_css_matches?
-        assert node = @html.at('a.bar')
-        assert node.matches?('a.bar')
-      end
-      def test_xpath_matches?
-        assert node = @html.at('//a')
-        assert node.matches?('//a')
-      end
-      def test_unlink_then_swap
-        node = @html.at('a')
-        node.unlink
-        another_node = @html.at('div')
-        assert another_node, 'should have a node'
-        # This used to segv
-        assert_nothing_raised do
-          node.add_previous_sibling another_node
-        end
-      end
-      def test_swap
-        @html.at('div').swap('<a href="foo">bar</a>')
-        a_tag = @html.css('a').first
-        assert_equal 'body', a_tag.parent.name
-        assert_equal 0, @html.css('div').length
-      end
-      def test_swap_with_regex_characters
-        @html.at('div').swap('<a href="foo">ba)r</a>')
-        a_tag = @html.css('a').first
-        assert_equal 'ba)r', a_tag.text
-      end
-      def test_attribute_decodes_entities
-        node = @html.at('div')
-        node['href'] = 'foo&bar'
-        assert_equal 'foo&bar', node['href']
-        node['href'] += '&baz'
-        assert_equal 'foo&bar&baz', node['href']
-      end
-      def test_parse_config_option
-        node = @html.at('div')
-        options = nil
-        node.parse("<div></div>") do |config|
-          options = config
-        end
-        assert_equal Nokogiri::XML::ParseOptions::DEFAULT_HTML, options.to_i
-      end
-      def test_fragment_handler_does_not_regurge_on_invalid_attributes
-        iframe = %Q{<iframe style="width: 0%; height: 0px" src="http://someurl" allowtransparency></iframe>}
-        assert_nothing_raised { @html.at('div').fragment(iframe) }
-      end
-      def test_fragment
-        fragment = @html.fragment(<<-eohtml)
-          hello
-          <div class="foo">
-            <p>bar</p>
-          </div>
-          world
-        eohtml
-        assert_match(/^hello/, fragment.inner_html.strip)
-        assert_equal 3, fragment.children.length
-        assert p_tag = fragment.css('p').first
-        assert_equal 'div', p_tag.parent.name
-        assert_equal 'foo', p_tag.parent['class']
-      end
-      def test_fragment_serialization
-        fragment = Nokogiri::HTML.fragment("<div>foo</div>")
-        assert_equal "<div>foo</div>", fragment.serialize.chomp
-        assert_equal "<div>foo</div>", fragment.to_xml.chomp
-        assert_equal "<div>foo</div>", fragment.inner_html
-        assert_equal "<div>foo</div>", fragment.to_html
-        assert_equal "<div>foo</div>", fragment.to_s
-      end
-      def test_to_html_does_not_contain_entities
-        return unless defined?(NKF) # NKF is not implemented on Rubinius as of 2009-11-23
-        html = NKF.nkf("-e --msdos", <<-EOH)
-        <html><body>
-        <p> test paragraph
-        foo bar </p>
-        </body></html>
-        EOH
-        nokogiri = Nokogiri::HTML.parse(html)
-        if RUBY_PLATFORM =~ /java/
-          # NKF linebreak modes are not supported as of jruby 1.2
-          # see http://jira.codehaus.org/browse/JRUBY-3602 for status
-          assert_equal "<p>testparagraph\nfoobar</p>",
-            nokogiri.at("p").to_html.gsub(/ /, '')
-        else
-          assert_equal "<p>testparagraph\r\nfoobar</p>",
-            nokogiri.at("p").to_html.gsub(/ /, '')
-        end
-      end
-    end
-  end
-end

data/build/bundler/ruby/1.9.1/gems/nokogiri-1.5.0-x86-mingw32/test/html/test_node_encoding.rb DELETED Viewed

@@ -1,27 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-module Nokogiri
-  module HTML
-    if RUBY_VERSION =~ /^1\.9/
-      class TestNodeEncoding < Nokogiri::TestCase
-        def test_inner_html
-          doc = Nokogiri::HTML File.open(SHIFT_JIS_HTML, 'rb')
-          hello = "こんにちは"
-          contents = doc.at('h2').inner_html
-          assert_equal doc.encoding, contents.encoding.name
-          assert_match hello.encode('Shift_JIS'), contents
-          contents = doc.at('h2').inner_html(:encoding => 'UTF-8')
-          assert_match hello, contents
-          doc.encoding = 'UTF-8'
-          contents = doc.at('h2').inner_html
-          assert_match hello, contents
-        end
-      end
-    end
-  end
-end