RubyGems - daslabs - Versions diffs - 0.12.0 → 0.13.0 - Mend

daslabs 0.12.0 → 0.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (535) hide show

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/test/html/test_document_encoding.rb DELETED

@@ -1,143 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-module Nokogiri
-  module HTML
-    class TestDocumentEncoding < Nokogiri::TestCase
-      def test_encoding
-        doc = Nokogiri::HTML File.open(SHIFT_JIS_HTML, 'rb')
-        hello = "こんにちは"
-        assert_match doc.encoding, doc.to_html
-        assert_match hello.encode('Shift_JIS'), doc.to_html
-        assert_equal 'Shift_JIS', doc.to_html.encoding.name
-        assert_match hello, doc.to_html(:encoding => 'UTF-8')
-        assert_match 'UTF-8', doc.to_html(:encoding => 'UTF-8')
-        assert_match 'UTF-8', doc.to_html(:encoding => 'UTF-8').encoding.name
-      end
-      def test_encoding_without_charset
-        doc = Nokogiri::HTML File.open(SHIFT_JIS_NO_CHARSET, 'r:cp932:cp932').read
-        hello = "こんにちは"
-        assert_match hello, doc.content
-        assert_match hello, doc.to_html(:encoding => 'UTF-8')
-        assert_match 'UTF-8', doc.to_html(:encoding => 'UTF-8').encoding.name
-      end
-      def test_default_to_encoding_from_string
-        bad_charset = <<-eohtml
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=charset=UTF-8">
-</head>
-<body>
-  <a href="http://tenderlovemaking.com/">blah!</a>
-</body>
-</html>
-        eohtml
-        doc = Nokogiri::HTML(bad_charset)
-        assert_equal bad_charset.encoding.name, doc.encoding
-        doc = Nokogiri.parse(bad_charset)
-        assert_equal bad_charset.encoding.name, doc.encoding
-      end
-      def test_encoding_non_utf8
-        orig = '日本語が上手です'
-        bin = Encoding::ASCII_8BIT
-        [Encoding::Shift_JIS, Encoding::EUC_JP].each do |enc|
-          html = <<-eohtml.encode(enc)
-<html>
-<meta http-equiv="Content-Type" content="text/html; charset=#{enc.name}">
-<title xml:lang="ja">#{orig}</title></html>
-          eohtml
-          text = Nokogiri::HTML.parse(html).at('title').inner_text
-          assert_equal(
-            orig.encode(enc).force_encoding(bin),
-            text.encode(enc).force_encoding(bin)
-          )
-        end
-      end
-      def test_encoding_with_a_bad_name
-        bad_charset = <<-eohtml
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=charset=UTF-8">
-</head>
-<body>
-  <a href="http://tenderlovemaking.com/">blah!</a>
-</body>
-</html>
-        eohtml
-        doc = Nokogiri::HTML(bad_charset, nil, 'askldjfhalsdfjhlkasdfjh')
-        assert_equal ['http://tenderlovemaking.com/'],
-          doc.css('a').map { |a| a['href'] }
-      end
-      def test_empty_doc_encoding
-        encoding = 'US-ASCII'
-        assert_equal encoding, Nokogiri::HTML.parse(nil, nil, encoding).encoding
-      end
-    end
-    class TestDocumentEncodingDetection < Nokogiri::TestCase
-      def binread(file)
-        IO.binread(file)
-      end
-      def binopen(file)
-        File.open(file, 'rb')
-      end
-      def test_document_html_noencoding
-        from_stream = Nokogiri::HTML(binopen(NOENCODING_FILE))
-        from_string = Nokogiri::HTML(binread(NOENCODING_FILE))
-        assert_equal from_string.to_s.size, from_stream.to_s.size
-      end
-      def test_document_html_charset
-        html = Nokogiri::HTML(binopen(METACHARSET_FILE))
-        assert_equal 'iso-2022-jp', html.encoding
-        assert_equal 'たこ焼き仮面', html.title
-      end
-      def test_document_xhtml_enc
-        [ENCODING_XHTML_FILE, ENCODING_HTML_FILE].each { |file|
-          doc_from_string_enc = Nokogiri::HTML(binread(file), nil, 'Shift_JIS')
-          ary_from_string_enc = doc_from_string_enc.xpath('//p/text()').map(&:text)
-          doc_from_string = Nokogiri::HTML(binread(file))
-          ary_from_string = doc_from_string.xpath('//p/text()').map(&:text)
-          doc_from_file_enc = Nokogiri::HTML(binopen(file), nil, 'Shift_JIS')
-          ary_from_file_enc = doc_from_file_enc.xpath('//p/text()').map(&:text)
-          doc_from_file = Nokogiri::HTML(binopen(file))
-          ary_from_file = doc_from_file.xpath('//p/text()').map(&:text)
-          title = 'たこ焼き仮面'
-          assert_equal(title, doc_from_string_enc.at('//title/text()').text)
-          assert_equal(title, doc_from_string.at('//title/text()').text)
-          assert_equal(title, doc_from_file_enc.at('//title/text()').text)
-          assert_equal(title, doc_from_file.at('//title/text()').text)
-          evil = (0..72).map { |i| '超' * i + '悪い事を構想中。' }
-          assert_equal(evil, ary_from_string_enc)
-          assert_equal(evil, ary_from_string)
-          assert_equal(evil, ary_from_file_enc)
-          assert_equal(evil, ary_from_file)
-        }
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/test/html/test_document_fragment.rb DELETED

@@ -1,304 +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
-      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
-      def test_unlink_empty_document
-        frag = Nokogiri::HTML::DocumentFragment.parse('').unlink # must_not_raise
-        assert_nil frag.parent
-      end
-      def test_colons_are_not_removed
-        doc = Nokogiri::HTML::DocumentFragment.parse("<span>3:30pm</span>")
-        assert_match(/3:30/, doc.to_s)
-      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_input_and_intermediate_whitespace
-        doc = "<label>Label</label><input type=\"text\"> <span>span</span>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_equal "<label>Label</label><input type=\"text\"> <span>span</span>", 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><p></p>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        if Nokogiri.jruby? || Nokogiri::VERSION_INFO['libxml']['loaded'] >= "2.7.0"
-          assert_equal "<span>foo<br /></span><span>bar</span><p></p>", fragment.to_xhtml
-        else
-          # FIXME: why are we doing this ? this violates the spec,
-          # see http://www.w3.org/TR/xhtml1/#C_2
-          assert_equal "<span>foo<br></span><span>bar</span><p></p>", 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_element_children_counts
-        if Nokogiri.uses_libxml? && Nokogiri::VERSION_INFO['libxml']['loaded'] <= "2.9.1"
-          skip "#elements doesn't work in 2.9.1, see 1793a5a for history"
-        end
-        doc = Nokogiri::HTML::DocumentFragment.parse("   <div>  </div>\n   ")
-        assert_equal 1, doc.element_children.count
-      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
-      def test_capturing_nonparse_errors_during_fragment_clone
-        # see https://github.com/sparklemotion/nokogiri/issues/1196 for background
-        original = Nokogiri::HTML.fragment("<div id='unique'></div><div id='unique'></div>")
-        original_errors = original.errors.dup
-        copy = original.dup
-        assert_equal original_errors, copy.errors
-      end
-      def test_capturing_nonparse_errors_during_node_copy_between_fragments
-        # Errors should be emitted while parsing only, and should not change when moving nodes.
-        frag1 = Nokogiri::HTML.fragment("<diva id='unique'>one</diva>")
-        frag2 = Nokogiri::HTML.fragment("<dive id='unique'>two</dive>")
-        node1 = frag1.at_css("#unique")
-        node2 = frag2.at_css("#unique")
-        original_errors1 = frag1.errors.dup
-        original_errors2 = frag2.errors.dup
-        assert original_errors1.any?{|e| e.to_s =~ /Tag diva invalid/ }, "it should complain about the tag name"
-        assert original_errors2.any?{|e| e.to_s =~ /Tag dive invalid/ }, "it should complain about the tag name"
-        node1.add_child node2
-        assert_equal original_errors1, frag1.errors
-        assert_equal original_errors2, frag2.errors
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/test/html/test_element_description.rb DELETED

@@ -1,105 +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_null_default_sub_element
-        doc = Nokogiri::HTML('foo')
-        doc.root.description.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