daslabs 0.4.0

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

@@ -0,0 +1,28 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class Node
+      class TestSaveOptions < Nokogiri::TestCase
+        SaveOptions.constants.each do |constant|
+          class_eval <<-EOEVAL
+            def test_predicate_#{constant.downcase}
+              options = SaveOptions.new(SaveOptions::#{constant})
+              assert options.#{constant.downcase}?
+
+              assert SaveOptions.new.#{constant.downcase}.#{constant.downcase}?
+            end
+          EOEVAL
+        end
+
+        def test_default_xml_save_options
+          if Nokogiri.jruby?
+            assert_equal 0, (SaveOptions::DEFAULT_XML & SaveOptions::FORMAT)
+          else
+            assert_equal SaveOptions::FORMAT, (SaveOptions::DEFAULT_XML & SaveOptions::FORMAT)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class Node
+      class TestSubclass < Nokogiri::TestCase
+        {
+          Nokogiri::XML::CDATA                  => 'doc, "foo"',
+          Nokogiri::XML::Attr                   => 'doc, "foo"',
+          Nokogiri::XML::Comment                => 'doc, "foo"',
+          Nokogiri::XML::EntityReference        => 'doc, "foo"',
+          Nokogiri::XML::ProcessingInstruction  => 'doc, "foo", "bar"',
+          Nokogiri::XML::DocumentFragment       => 'doc',
+          Nokogiri::XML::Node                   => '"foo", doc',
+          Nokogiri::XML::Text                   => '"foo", doc',
+        }.each do |klass, constructor|
+          class_eval %{
+            def test_subclass_#{klass.name.gsub('::', '_')}
+              doc = Nokogiri::XML::Document.new
+              klass = Class.new(#{klass.name})
+              node = klass.new(#{constructor})
+              assert_instance_of klass, node
+            end
+          }
+
+          class_eval <<-eocode, __FILE__, __LINE__ + 1
+            def test_subclass_initialize_#{klass.name.gsub('::', '_')}
+              doc = Nokogiri::XML::Document.new
+              klass = Class.new(#{klass.name}) do
+                attr_accessor :initialized_with
+
+                def initialize *args
+                  @initialized_with = args
+                end
+              end
+              node = klass.new(#{constructor}, 1)
+              assert_equal [#{constructor}, 1], node.initialized_with
+            end
+          eocode
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,394 @@
+# -*- coding: utf-8 -*-
+
+require "helper"
+
+module Nokogiri
+  module XML
+    module SAX
+      class TestParser < Nokogiri::SAX::TestCase
+        def setup
+          super
+          @parser = XML::SAX::Parser.new(Doc.new)
+        end
+
+        def test_parser_context_yielded_io
+          doc = Doc.new
+          parser = XML::SAX::Parser.new doc
+          xml = "<foo a='&amp;b'/>"
+
+          block_called = false
+          parser.parse(StringIO.new(xml)) { |ctx|
+            block_called = true
+            ctx.replace_entities = true
+          }
+
+          assert block_called
+
+          assert_equal [['foo', [['a', '&b']]]], doc.start_elements
+        end
+
+        def test_parser_context_yielded_in_memory
+          doc = Doc.new
+          parser = XML::SAX::Parser.new doc
+          xml = "<foo a='&amp;b'/>"
+
+          block_called = false
+          parser.parse(xml) { |ctx|
+            block_called = true
+            ctx.replace_entities = true
+          }
+
+          assert block_called
+
+          assert_equal [['foo', [['a', '&b']]]], doc.start_elements
+        end
+
+        def test_xml_decl
+          [
+            ['', nil],
+            ['<?xml version="1.0" ?>',
+              ['1.0']],
+            ['<?xml version="1.0" encoding="UTF-8" ?>',
+              ['1.0', 'UTF-8']],
+            ['<?xml version="1.0" standalone="yes"?>',
+              ['1.0', 'yes']],
+            ['<?xml version="1.0" standalone="no"?>',
+              ['1.0', 'no']],
+            ['<?xml version="1.0" encoding="UTF-8" standalone="no"?>',
+              ['1.0', "UTF-8", 'no']],
+            ['<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>',
+              ['1.0', "ISO-8859-1", 'yes']]
+          ].each do |decl, value|
+            parser = XML::SAX::Parser.new(Doc.new)
+
+            xml = "#{decl}\n<root />"
+            parser.parse xml
+            assert parser.document.start_document_called, xml
+            assert_equal value, parser.document.xmldecls, xml
+          end
+        end
+
+        def test_parse_empty
+          assert_raises RuntimeError do
+            @parser.parse('')
+          end
+        end
+
+        def test_namespace_declaration_order_is_saved
+          @parser.parse <<-eoxml
+<root xmlns:foo='http://foo.example.com/' xmlns='http://example.com/'>
+  <a foo:bar='hello' />
+</root>
+          eoxml
+          assert_equal 2, @parser.document.start_elements_namespace.length
+          el = @parser.document.start_elements_namespace.first
+          namespaces = el.last
+          assert_equal ['foo', 'http://foo.example.com/'], namespaces.first
+          assert_equal [nil, 'http://example.com/'], namespaces.last
+        end
+
+        def test_bad_document_calls_error_handler
+          @parser.parse('<foo><bar></foo>')
+          assert @parser.document.errors
+          assert @parser.document.errors.length > 0
+        end
+
+        def test_namespace_are_super_fun_to_parse
+          @parser.parse <<-eoxml
+<root xmlns:foo='http://foo.example.com/'>
+  <a foo:bar='hello' />
+  <b xmlns:foo='http://bar.example.com/'>
+    <a foo:bar='hello' />
+  </b>
+  <foo:bar>hello world</foo:bar>
+</root>
+          eoxml
+
+          assert @parser.document.start_elements_namespace.length > 0
+          el = @parser.document.start_elements_namespace[1]
+          assert_equal 'a', el.first
+          assert_equal 1, el[1].length
+
+          attribute = el[1].first
+          assert_equal 'bar', attribute.localname
+          assert_equal 'foo', attribute.prefix
+          assert_equal 'hello', attribute.value
+          assert_equal 'http://foo.example.com/', attribute.uri
+        end
+
+        def test_sax_v1_namespace_attribute_declarations
+          @parser.parse <<-eoxml
+<root xmlns:foo='http://foo.example.com/' xmlns='http://example.com/'>
+  <a foo:bar='hello' />
+  <b xmlns:foo='http://bar.example.com/'>
+    <a foo:bar='hello' />
+  </b>
+  <foo:bar>hello world</foo:bar>
+</root>
+          eoxml
+          assert @parser.document.start_elements.length > 0
+          elm = @parser.document.start_elements.first
+          assert_equal 'root', elm.first
+          assert elm[1].include?(['xmlns:foo', 'http://foo.example.com/'])
+          assert elm[1].include?(['xmlns', 'http://example.com/'])
+        end
+
+        def test_sax_v1_namespace_nodes
+          @parser.parse <<-eoxml
+<root xmlns:foo='http://foo.example.com/' xmlns='http://example.com/'>
+  <a foo:bar='hello' />
+  <b xmlns:foo='http://bar.example.com/'>
+    <a foo:bar='hello' />
+  </b>
+  <foo:bar>hello world</foo:bar>
+</root>
+          eoxml
+          assert_equal 5, @parser.document.start_elements.length
+          assert @parser.document.start_elements.map(&:first).include?('foo:bar')
+          assert @parser.document.end_elements.map(&:first).include?('foo:bar')
+        end
+
+        def test_start_is_called_without_namespace
+          @parser.parse(<<-eoxml)
+<root xmlns:foo='http://foo.example.com/' xmlns='http://example.com/'>
+<foo:f><bar></foo:f>
+</root>
+          eoxml
+          assert_equal ['root', 'foo:f', 'bar'],
+            @parser.document.start_elements.map(&:first)
+        end
+
+        def test_parser_sets_encoding
+          parser = XML::SAX::Parser.new(Doc.new, 'UTF-8')
+          assert_equal 'UTF-8', parser.encoding
+        end
+
+        def test_errors_set_after_parsing_bad_dom
+          doc = Nokogiri::XML('<foo><bar></foo>')
+          assert doc.errors
+
+          @parser.parse('<foo><bar></foo>')
+          assert @parser.document.errors
+          assert @parser.document.errors.length > 0
+
+          doc.errors.each do |error|
+            assert_equal 'UTF-8', error.message.encoding.name
+          end
+
+          # when using JRuby Nokogiri, more errors will be generated as the DOM
+          # parser continue to parse an ill formed document, while the sax parser
+          # will stop at the first error
+          unless Nokogiri.jruby?
+            assert_equal doc.errors.length, @parser.document.errors.length
+          end
+        end
+
+        def test_parse_with_memory_argument
+          @parser.parse(File.read(XML_FILE))
+          assert(@parser.document.cdata_blocks.length > 0)
+        end
+
+        def test_parse_with_io_argument
+          File.open(XML_FILE, 'rb') { |f|
+            @parser.parse(f)
+          }
+          assert(@parser.document.cdata_blocks.length > 0)
+        end
+
+        def test_parse_io
+          call_parse_io_with_encoding 'UTF-8'
+        end
+
+        # issue #828
+        def test_parse_io_lower_case_encoding
+          call_parse_io_with_encoding 'utf-8'
+        end
+
+        def call_parse_io_with_encoding encoding
+          File.open(XML_FILE, 'rb') { |f|
+            @parser.parse_io(f, encoding)
+          }
+          assert(@parser.document.cdata_blocks.length > 0)
+
+          called = false
+          @parser.document.start_elements.flatten.each do |thing|
+            assert_equal 'UTF-8', thing.encoding.name
+            called = true
+          end
+          assert called
+
+          called = false
+          @parser.document.end_elements.flatten.each do |thing|
+            assert_equal 'UTF-8', thing.encoding.name
+            called = true
+          end
+          assert called
+
+          called = false
+          @parser.document.data.each do |thing|
+            assert_equal 'UTF-8', thing.encoding.name
+            called = true
+          end
+          assert called
+
+          called = false
+          @parser.document.comments.flatten.each do |thing|
+            assert_equal 'UTF-8', thing.encoding.name
+            called = true
+          end
+          assert called
+
+          called = false
+          @parser.document.cdata_blocks.flatten.each do |thing|
+            assert_equal 'UTF-8', thing.encoding.name
+            called = true
+          end
+          assert called
+        end
+
+        def test_parse_file
+          @parser.parse_file(XML_FILE)
+
+          assert_raises(ArgumentError) {
+            @parser.parse_file(nil)
+          }
+
+          assert_raises(Errno::ENOENT) {
+            @parser.parse_file('')
+          }
+          assert_raises(Errno::EISDIR) {
+            @parser.parse_file(File.expand_path(File.dirname(__FILE__)))
+          }
+        end
+
+        def test_render_parse_nil_param
+          assert_raises(ArgumentError) { @parser.parse_memory(nil) }
+        end
+
+        def test_bad_encoding_args
+          assert_raises(ArgumentError) { XML::SAX::Parser.new(Doc.new, 'not an encoding') }
+          assert_raises(ArgumentError) { @parser.parse_io(StringIO.new('<root/>'), 'not an encoding')}
+        end
+
+        def test_ctag
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">
+              <![CDATA[ This is a comment ]]>
+              Paragraph 1
+            </p>
+          eoxml
+          assert_equal [' This is a comment '], @parser.document.cdata_blocks
+        end
+
+        def test_comment
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">
+              <!-- This is a comment -->
+              Paragraph 1
+            </p>
+          eoxml
+          assert_equal [' This is a comment '], @parser.document.comments
+        end
+
+        def test_characters
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">Paragraph 1</p>
+          eoxml
+          assert_equal ['Paragraph 1'], @parser.document.data
+        end
+
+        def test_end_document
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">Paragraph 1</p>
+          eoxml
+          assert @parser.document.end_document_called
+        end
+
+        def test_end_element
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">Paragraph 1</p>
+          eoxml
+          assert_equal [["p"]],
+            @parser.document.end_elements
+        end
+
+        def test_start_element_attrs
+          @parser.parse_memory(<<-eoxml)
+            <p id="asdfasdf">Paragraph 1</p>
+          eoxml
+          assert_equal [["p", [["id", "asdfasdf"]]]],
+                       @parser.document.start_elements
+        end
+
+        def test_start_element_attrs_include_namespaces
+          @parser.parse_memory(<<-eoxml)
+            <p xmlns:foo='http://foo.example.com/'>Paragraph 1</p>
+          eoxml
+          assert_equal [["p", [['xmlns:foo', 'http://foo.example.com/']]]],
+                       @parser.document.start_elements
+        end
+
+        def test_processing_instruction
+          @parser.parse_memory(<<-eoxml)
+            <?xml-stylesheet href="a.xsl" type="text/xsl"?>
+            <?xml version="1.0"?>
+          eoxml
+          assert_equal [['xml-stylesheet', 'href="a.xsl" type="text/xsl"']],
+                       @parser.document.processing_instructions
+        end
+
+        if Nokogiri.uses_libxml? # JRuby SAXParser only parses well-formed XML documents
+          def test_parse_document
+            @parser.parse_memory(<<-eoxml)
+              <p>Paragraph 1</p>
+              <p>Paragraph 2</p>
+            eoxml
+          end
+        end
+
+        def test_parser_attributes
+          xml = <<-eoxml
+<?xml version="1.0" ?><root><foo a="&amp;b" c="&gt;d" /></root>
+          eoxml
+
+          block_called = false
+          @parser.parse(xml) { |ctx|
+            block_called = true
+            ctx.replace_entities = true
+          }
+
+          assert block_called
+
+          assert_equal [['root', []], ['foo', [['a', '&b'], ['c', '>d']]]], @parser.document.start_elements
+        end
+
+        def test_recovery_from_incorrect_xml
+          xml = <<-eoxml
+<?xml version="1.0" ?><Root><Data><?xml version='1.0'?><Item>hey</Item></Data><Data><Item>hey yourself</Item></Data></Root>
+          eoxml
+
+          block_called = false
+          @parser.parse(xml) { |ctx|
+            block_called = true
+            ctx.recovery = true
+          }
+
+          assert block_called
+
+          assert_equal [['Root', []], ['Data', []], ['Item', []], ['Data', []], ['Item', []]], @parser.document.start_elements
+        end
+
+        def test_square_bracket_in_text  # issue 1261
+          xml = <<-eoxml
+<tu tuid="87dea04cf60af103ff09d1dba36ae820" segtype="block">
+  <prop type="x-smartling-string-variant">en:#:home_page:#:stories:#:[6]:#:name</prop>
+  <tuv xml:lang="en-US"><seg>Sandy S.</seg></tuv>
+</tu>
+          eoxml
+          @parser.parse(xml)
+          assert @parser.document.data.must_include "en:#:home_page:#:stories:#:[6]:#:name"
+        end
+      end
+    end
+  end
+end