daslabs 0.12.0 → 0.13.0

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/test/xml/test_parse_options.rb

@@ -1,64 +0,0 @@
-require "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_unsetting
-        options = Nokogiri::XML::ParseOptions.new Nokogiri::XML::ParseOptions::DEFAULT_HTML
-        assert options.nonet?
-        assert options.recover?
-        options.nononet.norecover
-        assert ! options.nonet?
-        assert ! options.recover?
-        options.nonet.recover
-        assert options.nonet?
-        assert options.recover?
-      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/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/test/xml/test_processing_instruction.rb

@@ -1,30 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestProcessingInstruction < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
-      end
-
-      def test_type
-        assert_equal(Node::PI_NODE, @xml.children[0].type)
-      end
-
-      def test_name
-        assert_equal 'TEST-STYLE', @xml.children[0].name
-      end
-
-      def test_new
-        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/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/test/xml/test_reader.rb

@@ -1,608 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestReader < Nokogiri::TestCase
-      def test_from_io_sets_io_as_source
-        io = File.open SNUGGLES_FILE
-        reader = Nokogiri::XML::Reader.from_io(io)
-        assert_equal io, reader.source
-      end
-
-      def test_empty_element?
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-          <xml><city>Paris</city><state/></xml>
-        eoxml
-
-        results = reader.map do |node|
-          if node.node_type == Nokogiri::XML::Node::ELEMENT_NODE
-            node.empty_element?
-          end
-        end
-        assert_equal [false, false, nil, nil, true, nil], results
-      end
-
-      def test_self_closing?
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-          <xml><city>Paris</city><state/></xml>
-        eoxml
-
-        results = reader.map do |node|
-          if node.node_type == Nokogiri::XML::Node::ELEMENT_NODE
-            node.self_closing?
-          end
-        end
-        assert_equal [false, false, nil, nil, true, nil], results
-      end
-
-      # Issue #831
-      # Make sure that the reader doesn't block reading the entire input
-      def test_reader_blocking
-        rd, wr = IO.pipe()
-        node_out = nil
-        t = Thread.start do
-          reader = Nokogiri::XML::Reader(rd, 'UTF-8')
-          reader.each do |node|
-            node_out = node
-            break
-          end
-          rd.close
-        end
-        sleep(1)              # sleep for one second to make sure the reader will actually block for input
-        begin
-          wr.puts "<foo>"
-          wr.puts "<bar/>" * 10000
-          wr.flush
-        rescue Errno::EPIPE
-        end
-        res = t.join(5)    # wait 5 seconds for the thread to finish
-        wr.close
-        refute_nil node_out, "Didn't read any nodes, exclude the trivial case"
-        refute_nil res, "Reader blocks trying to read the entire stream"
-      end
-
-      def test_reader_takes_block
-        options = nil
-        Nokogiri::XML::Reader(File.read(XML_FILE), XML_FILE) do |cfg|
-          options = cfg
-          options.nonet.nowarning.dtdattr
-        end
-        assert options.nonet?
-        assert options.nowarning?
-        assert options.dtdattr?
-      end
-
-      def test_nil_raises
-        assert_raises(ArgumentError) {
-          Nokogiri::XML::Reader.from_memory(nil)
-        }
-        assert_raises(ArgumentError) {
-          Nokogiri::XML::Reader.from_io(nil)
-        }
-      end
-
-      def test_from_io
-        io = File.open SNUGGLES_FILE
-        reader = Nokogiri::XML::Reader.from_io(io)
-        assert_equal false, reader.default?
-        assert_equal [false, false, false, false, false, false, false],
-          reader.map(&:default?)
-      end
-
-      def test_io
-        io = File.open SNUGGLES_FILE
-        reader = Nokogiri::XML::Reader(io)
-        assert_equal false, reader.default?
-        assert_equal [false, false, false, false, false, false, false],
-          reader.map(&:default?)
-      end
-
-      def test_string_io
-        io = StringIO.new(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        reader = Nokogiri::XML::Reader(io)
-        assert_equal false, reader.default?
-        assert_equal [false, false, false, false, false, false, false],
-          reader.map(&:default?)
-      end
-
-      class ReallyBadIO
-        def read(size)
-          'a' * size ** 10
-        end
-      end
-
-      class ReallyBadIO4Java
-        def read(size=1)
-          'a' * size ** 10
-        end
-      end
-
-      def test_io_that_reads_too_much
-        if Nokogiri.jruby?
-          io = ReallyBadIO4Java.new
-          Nokogiri::XML::Reader(io)
-        else
-          io = ReallyBadIO.new
-          Nokogiri::XML::Reader(io)
-        end
-      end
-
-      def test_in_memory
-        assert Nokogiri::XML::Reader(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-      end
-
-      def test_reader_holds_on_to_string
-        xml = <<-eoxml
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        reader = Nokogiri::XML::Reader(xml)
-        assert_equal xml, reader.source
-      end
-
-      def test_default?
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        assert_equal false, reader.default?
-        assert_equal [false, false, false, false, false, false, false],
-          reader.map(&:default?)
-      end
-
-      def test_value?
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        assert_equal false, reader.value?
-        assert_equal [false, true, false, true, false, true, false],
-          reader.map(&:value?)
-      end
-
-      def test_read_error_document
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-          <foo>
-        </x>
-        eoxml
-        assert_raises(Nokogiri::XML::SyntaxError) do
-          reader.each { |node| }
-        end
-        assert 1, reader.errors.length
-      end
-
-      def test_errors_is_an_array
-        reader = Nokogiri::XML::Reader(StringIO.new('&bogus;'))
-        assert_raises(SyntaxError) {
-          reader.read
-        }
-        assert_equal [SyntaxError], reader.errors.map(&:class)
-      end
-
-      def test_pushing_to_non_array_raises_TypeError
-        skip "TODO: JRuby ext does not internally call `errors`" if Nokogiri.jruby?
-        reader = Nokogiri::XML::Reader(StringIO.new('&bogus;'))
-        def reader.errors
-          1
-        end
-        assert_raises(TypeError) {
-          reader.read
-        }
-      end
-
-      def test_attributes?
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        assert_equal false, reader.attributes?
-        assert_equal [true, false, true, false, true, false, true],
-          reader.map(&:attributes?)
-      end
-
-      def test_attributes
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'
-           xmlns='http://mothership.connection.com/'
-           >
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        assert_equal({}, reader.attributes)
-        assert_equal [{'xmlns:tenderlove'=>'http://tenderlovemaking.com/',
-                       'xmlns'=>'http://mothership.connection.com/'},
-                      {}, {"awesome"=>"true"}, {}, {"awesome"=>"true"}, {},
-                      {'xmlns:tenderlove'=>'http://tenderlovemaking.com/',
-                       'xmlns'=>'http://mothership.connection.com/'}],
-          reader.map(&:attributes)
-      end
-
-      def test_attribute_roundtrip
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'
-           xmlns='http://mothership.connection.com/'
-           >
-          <tenderlove:foo awesome='true' size='giant'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        reader.each do |node|
-          node.attributes.each do |key, value|
-            assert_equal value, node.attribute(key)
-          end
-        end
-      end
-
-      def test_attribute_at
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        assert_nil reader.attribute_at(nil)
-        assert_nil reader.attribute_at(0)
-        assert_equal ['http://tenderlovemaking.com/', nil, 'true', nil, 'true', nil, 'http://tenderlovemaking.com/'],
-          reader.map { |x| x.attribute_at(0) }
-      end
-
-      def test_attribute
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        assert_nil reader.attribute(nil)
-        assert_nil reader.attribute('awesome')
-        assert_equal [nil, nil, 'true', nil, 'true', nil, nil],
-          reader.map { |x| x.attribute('awesome') }
-      end
-
-      def test_attribute_length
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        assert_equal 0, reader.attribute_count
-        assert_equal [1, 0, 1, 0, 0, 0, 0], reader.map(&:attribute_count)
-      end
-
-      def test_depth
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        assert_equal 0, reader.depth
-        assert_equal [0, 1, 1, 2, 1, 1, 0], reader.map(&:depth)
-      end
-
-      def test_encoding
-        string = <<-eoxml
-        <awesome>
-          <p xml:lang="en">The quick brown fox jumps over the lazy dog.</p>
-          <p xml:lang="ja">日本語が上手です</p>
-        </awesome>
-        eoxml
-        reader = Nokogiri::XML::Reader.from_memory(string, nil, 'UTF-8')
-        assert_equal ['UTF-8'], reader.map(&:encoding).uniq
-      end
-
-      def test_xml_version
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        assert_nil reader.xml_version
-        assert_equal ['1.0'], reader.map(&:xml_version).uniq
-      end
-
-      def test_lang
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <awesome>
-          <p xml:lang="en">The quick brown fox jumps over the lazy dog.</p>
-          <p xml:lang="ja">日本語が上手です</p>
-        </awesome>
-        eoxml
-        assert_nil reader.lang
-        assert_equal [nil, nil, "en", "en", "en", nil, "ja", "ja", "ja", nil, nil],
-          reader.map(&:lang)
-      end
-
-      def test_value
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-          <tenderlove:foo>snuggles!</tenderlove:foo>
-        </x>
-        eoxml
-        assert_nil reader.value
-        assert_equal [nil, "\n          ", nil, "snuggles!", nil, "\n        ", nil],
-          reader.map(&:value)
-      end
-
-      def test_prefix
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:edi='http://ecommerce.example.org/schema'>
-          <edi:foo>hello</edi:foo>
-        </x>
-        eoxml
-        assert_nil reader.prefix
-        assert_equal [nil, nil, "edi", nil, "edi", nil, nil],
-          reader.map(&:prefix)
-      end
-
-      def test_node_type
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x>
-          <y>hello</y>
-        </x>
-        eoxml
-        assert_equal 0, reader.node_type
-        assert_equal [1, 14, 1, 3, 15, 14, 15], reader.map(&:node_type)
-      end
-
-      def test_inner_xml
-        str = "<x><y>hello</y></x>"
-        reader = Nokogiri::XML::Reader.from_memory(str)
-
-        reader.read
-
-        assert_equal "<y>hello</y>", reader.inner_xml
-      end
-
-      def test_outer_xml
-        str = ["<x><y>hello</y></x>", "<y>hello</y>", "hello", "<y/>", "<x/>"]
-        reader = Nokogiri::XML::Reader.from_memory(str.first)
-
-        xml = []
-        reader.map { |node| xml << node.outer_xml }
-
-        assert_equal str, xml
-      end
-
-      def test_outer_xml_with_empty_nodes
-        str = ["<x><y/></x>", "<y/>", "<x/>"]
-        reader = Nokogiri::XML::Reader.from_memory(str.first)
-
-        xml = []
-        reader.map { |node| xml << node.outer_xml }
-
-        assert_equal str, xml
-      end
-
-      def test_state
-        reader = Nokogiri::XML::Reader.from_memory('<foo>bar</bar>')
-        assert reader.state
-      end
-
-      def test_ns_uri
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:edi='http://ecommerce.example.org/schema'>
-          <edi:foo>hello</edi:foo>
-        </x>
-        eoxml
-        assert_nil reader.namespace_uri
-        assert_equal([nil,
-                      nil,
-                      "http://ecommerce.example.org/schema",
-                      nil,
-                      "http://ecommerce.example.org/schema",
-                      nil,
-                      nil],
-                      reader.map(&:namespace_uri))
-      end
-
-      def test_namespaced_attributes
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:edi='http://ecommerce.example.org/schema' xmlns:commons="http://rets.org/xsd/RETSCommons">
-          <edi:foo commons:street-number="43">hello</edi:foo>
-          <y edi:name="francis" bacon="87"/>
-        </x>
-        eoxml
-        attr_ns = []
-        while reader.read
-          if reader.node_type == Nokogiri::XML::Node::ELEMENT_NODE
-            reader.attribute_nodes.each {|attr| attr_ns << (attr.namespace.nil? ? nil : attr.namespace.prefix) }
-          end
-        end
-        assert_equal(['commons',
-                      'edi',
-                      nil],
-                     attr_ns)
-      end
-
-      def test_local_name
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:edi='http://ecommerce.example.org/schema'>
-          <edi:foo>hello</edi:foo>
-        </x>
-        eoxml
-        assert_nil reader.local_name
-        assert_equal(["x", "#text", "foo", "#text", "foo", "#text", "x"],
-                     reader.map(&:local_name))
-      end
-
-      def test_name
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-        <x xmlns:edi='http://ecommerce.example.org/schema'>
-          <edi:foo>hello</edi:foo>
-        </x>
-        eoxml
-        assert_nil reader.name
-        assert_equal(["x", "#text", "edi:foo", "#text", "edi:foo", "#text", "x"],
-                     reader.map(&:name))
-      end
-
-      def test_base_uri
-        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-          <x xml:base="http://base.example.org/base/">
-            <link href="link"/>
-            <other xml:base="http://other.example.org/"/>
-            <relative xml:base="relative">
-              <link href="stuff" />
-            </relative>
-          </x>
-        eoxml
-
-        assert_nil reader.base_uri
-        assert_equal(["http://base.example.org/base/",
-                      "http://base.example.org/base/",
-                      "http://base.example.org/base/",
-                      "http://base.example.org/base/",
-                      "http://other.example.org/",
-                      "http://base.example.org/base/",
-                      "http://base.example.org/base/relative",
-                      "http://base.example.org/base/relative",
-                      "http://base.example.org/base/relative",
-                      "http://base.example.org/base/relative",
-                      "http://base.example.org/base/relative",
-                      "http://base.example.org/base/",
-                      "http://base.example.org/base/"],
-                      reader.map(&:base_uri))
-      end
-
-      def test_xlink_href_without_base_uri
-        reader = Nokogiri::XML::Reader(<<-eoxml)
-          <x xmlns:xlink="http://www.w3.org/1999/xlink">
-            <link xlink:href="#other">Link</link>
-            <other id="other">Linked Element</other>
-          </x>
-        eoxml
-
-        reader.each do |node|
-          if node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
-            if node.name == 'link'
-              assert_nil node.base_uri
-            end
-          end
-        end
-      end
-
-      def test_xlink_href_with_base_uri
-        reader = Nokogiri::XML::Reader(<<-eoxml)
-          <x xml:base="http://base.example.org/base/"
-             xmlns:xlink="http://www.w3.org/1999/xlink">
-            <link xlink:href="#other">Link</link>
-            <other id="other">Linked Element</other>
-          </x>
-        eoxml
-
-        reader.each do |node|
-          if node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
-            assert_equal node.base_uri, "http://base.example.org/base/"
-          end
-        end
-      end
-
-      def test_read_from_memory
-        called = false
-        reader = Nokogiri::XML::Reader.from_memory('<foo>bar</foo>')
-        reader.each do |node|
-          called = true
-          assert node
-        end
-        assert called
-      end
-
-      def test_large_document_smoke_test
-        #  simply run on a large document to verify that there no GC issues
-        xml = []
-        xml << "<elements>"
-        10000.times { |j| xml << "<element id=\"#{j}\"/>" }
-        xml << "</elements>"
-        xml = xml.join("\n")
-
-        Nokogiri::XML::Reader.from_memory(xml).each do |e|
-          e.attributes
-        end
-      end
-
-      def test_correct_outer_xml_inclusion
-        xml = Nokogiri::XML::Reader.from_io(StringIO.new(<<-eoxml))
-          <root-element>
-            <children>
-              <child n="1">
-                <field>child-1</field>
-              </child>
-              <child n="2">
-                <field>child-2</field>
-              </child>
-              <child n="3">
-                <field>child-3</field>
-              </child>
-            </children>
-          </root-element>
-        eoxml
-
-        nodelengths = []
-        has_child2 = []
-
-        xml.each do |node|
-          if node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT and node.name == "child"
-            nodelengths << node.outer_xml.length
-            has_child2 << !!(node.outer_xml =~ /child-2/)
-          end
-        end
-
-        assert_equal(nodelengths[0], nodelengths[1])
-        assert(has_child2[1])
-        assert(!has_child2[0])
-      end
-
-      def test_correct_inner_xml_inclusion
-        xml = Nokogiri::XML::Reader.from_io(StringIO.new(<<-eoxml))
-          <root-element>
-            <children>
-              <child n="1">
-                <field>child-1</field>
-              </child>
-              <child n="2">
-                <field>child-2</field>
-              </child>
-              <child n="3">
-                <field>child-3</field>
-              </child>
-            </children>
-          </root-element>
-        eoxml
-
-        nodelengths = []
-        has_child2 = []
-
-        xml.each do |node|
-          if node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT and node.name == "child"
-            nodelengths << node.inner_xml.length
-            has_child2 << !!(node.inner_xml =~ /child-2/)
-          end
-        end
-
-        assert_equal(nodelengths[0], nodelengths[1])
-        assert(has_child2[1])
-        assert(!has_child2[0])
-      end
-
-      def test_nonexistent_attribute
-        require 'nokogiri'
-        reader = Nokogiri::XML::Reader("<root xmlns='bob'><el attr='fred' /></root>")
-        reader.read # root
-        reader.read # el
-        assert_equal nil, reader.attribute('other')
-      end
-    end
-  end
-end