rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/test/xml/sax/test_parser.rb

@@ -1,382 +0,0 @@
-# -*- 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'],
-          }.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 { |se|
-            se.first
-          }.include?('foo:bar')
-          assert @parser.document.end_elements.map { |se|
-            se.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 { |x| x.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
-
-          if RUBY_VERSION =~ /^1\.9/
-            doc.errors.each do |error|
-              assert_equal 'UTF-8', error.message.encoding.name
-            end
-          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)
-          if RUBY_VERSION =~ /^1\.9/
-            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
-        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
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/test/xml/sax/test_parser_context.rb

@@ -1,115 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require "helper"
-
-module Nokogiri
-  module XML
-    module SAX
-      class TestParserContext < Nokogiri::SAX::TestCase
-        def setup
-          @xml = '<hello>
-
-world
-<inter>
-    <net>
-    </net>
-</inter>
-
-</hello>'
-        end
-
-        class Counter < Nokogiri::XML::SAX::Document
-          attr_accessor :context, :lines, :columns
-          def initialize
-            @context = nil
-            @lines   = []
-            @columns = []
-          end
-
-          def start_element name, attrs = []
-            @lines << [name, context.line]
-            @columns << [name, context.column]
-          end
-        end
-
-        def test_line_numbers
-          sax_handler = Counter.new
-
-          parser = Nokogiri::XML::SAX::Parser.new(sax_handler)
-          parser.parse(@xml) do |ctx|
-            sax_handler.context = ctx
-          end
-
-          assert_equal [["hello", 1], ["inter", 4], ["net", 5]],
-            sax_handler.lines
-        end
-
-        def test_column_numbers
-          sax_handler = Counter.new
-
-          parser = Nokogiri::XML::SAX::Parser.new(sax_handler)
-          parser.parse(@xml) do |ctx|
-            sax_handler.context = ctx
-          end
-
-          assert_equal [["hello", 7], ["inter", 7], ["net", 9]],
-            sax_handler.columns
-        end
-
-        def test_replace_entities
-          pc = ParserContext.new StringIO.new('<root />'), 'UTF-8'
-          pc.replace_entities = false
-          assert_equal false, pc.replace_entities
-
-          pc.replace_entities = true
-          assert_equal true, pc.replace_entities
-        end
-
-        def test_recovery
-          pc = ParserContext.new StringIO.new('<root />'), 'UTF-8'
-          pc.recovery = false
-          assert_equal false, pc.recovery
-
-          pc.recovery = true
-          assert_equal true, pc.recovery
-        end
-
-        def test_from_io
-          ctx = ParserContext.new StringIO.new('fo'), 'UTF-8'
-          assert ctx
-        end
-
-        def test_from_string
-          assert ParserContext.new 'blah blah'
-        end
-
-        def test_parse_with
-          ctx = ParserContext.new 'blah'
-          assert_raises ArgumentError do
-            ctx.parse_with nil
-          end
-        end
-
-        def test_parse_with_sax_parser
-          xml = "<root />"
-          ctx = ParserContext.new xml
-          parser = Parser.new Doc.new
-          assert_nil ctx.parse_with parser
-        end
-
-        def test_from_file
-          ctx = ParserContext.file XML_FILE
-          parser = Parser.new Doc.new
-          assert_nil ctx.parse_with parser
-        end
-
-        def test_parse_with_returns_nil
-          xml = "<root />"
-          ctx = ParserContext.new xml
-          parser = Parser.new Doc.new
-          assert_nil ctx.parse_with(parser)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/test/xml/sax/test_push_parser.rb

@@ -1,157 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require "helper"
-
-module Nokogiri
-  module XML
-    module SAX
-      class TestPushParser < Nokogiri::SAX::TestCase
-        def setup
-          super
-          @parser = XML::SAX::PushParser.new(Doc.new)
-        end
-
-        def test_exception
-          assert_raises(SyntaxError) do
-            @parser << "<foo /><foo />"
-          end
-
-          assert_raises(SyntaxError) do
-            @parser << nil
-          end
-        end
-
-        def test_end_document_called
-          @parser.<<(<<-eoxml)
-            <p id="asdfasdf">
-              <!-- This is a comment -->
-              Paragraph 1
-            </p>
-          eoxml
-          assert ! @parser.document.end_document_called
-          @parser.finish
-          assert @parser.document.end_document_called
-        end
-
-        def test_start_element
-          @parser.<<(<<-eoxml)
-            <p id="asdfasdf">
-          eoxml
-
-          assert_equal [["p", [["id", "asdfasdf"]]]],
-            @parser.document.start_elements
-
-          @parser.<<(<<-eoxml)
-              <!-- This is a comment -->
-              Paragraph 1
-            </p>
-          eoxml
-          assert_equal [' This is a comment '], @parser.document.comments
-          @parser.finish
-        end
-
-        def test_start_element_with_namespaces
-          @parser.<<(<<-eoxml)
-            <p xmlns:foo="http://foo.example.com/">
-          eoxml
-
-          assert_equal [["p", [["xmlns:foo", "http://foo.example.com/"]]]],
-            @parser.document.start_elements
-
-          @parser.<<(<<-eoxml)
-              <!-- This is a comment -->
-              Paragraph 1
-            </p>
-          eoxml
-          assert_equal [' This is a comment '], @parser.document.comments
-          @parser.finish
-        end
-
-        def test_start_element_ns
-          @parser.<<(<<-eoxml)
-            <stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0' size='large'></stream:stream>
-          eoxml
-
-          assert_equal 1, @parser.document.start_elements_namespace.length
-          el = @parser.document.start_elements_namespace.first
-
-          assert_equal 'stream', el.first
-          assert_equal 2, el[1].length
-          assert_equal [['version', '1.0'], ['size', 'large']],
-            el[1].map { |x| [x.localname, x.value] }
-
-          assert_equal 'stream', el[2]
-          assert_equal 'http://etherx.jabber.org/streams', el[3]
-          @parser.finish
-        end
-
-        def test_end_element_ns
-          @parser.<<(<<-eoxml)
-            <stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0'></stream:stream>
-          eoxml
-
-          assert_equal [['stream', 'stream', 'http://etherx.jabber.org/streams']],
-            @parser.document.end_elements_namespace
-          @parser.finish
-        end
-
-        def test_chevron_partial_xml
-          @parser.<<(<<-eoxml)
-            <p id="asdfasdf">
-          eoxml
-
-          @parser.<<(<<-eoxml)
-              <!-- This is a comment -->
-              Paragraph 1
-            </p>
-          eoxml
-          assert_equal [' This is a comment '], @parser.document.comments
-          @parser.finish
-        end
-
-        def test_chevron
-          @parser.<<(<<-eoxml)
-            <p id="asdfasdf">
-              <!-- This is a comment -->
-              Paragraph 1
-            </p>
-          eoxml
-          @parser.finish
-          assert_equal [' This is a comment '], @parser.document.comments
-        end
-
-        def test_default_options
-          assert_equal 0, @parser.options
-        end
-
-        def test_recover
-          @parser.options |= XML::ParseOptions::RECOVER
-          @parser.<<(<<-eoxml)
-            <p>
-              Foo
-              <bar>
-              Bar
-            </p>
-          eoxml
-          @parser.finish
-          assert(@parser.document.errors.size >= 1)
-          assert_equal [["p", []], ["bar", []]], @parser.document.start_elements
-          assert_equal "FooBar", @parser.document.data.map { |x|
-            x.gsub(/\s/, '')
-          }.join
-        end
-
-        def test_broken_encoding
-          skip("ultra hard to fix for pure Java version") if Nokogiri.jruby?
-          @parser.options |= XML::ParseOptions::RECOVER
-          # This is ISO_8859-1:
-          @parser.<< "<?xml version='1.0' encoding='UTF-8'?><r>Gau\337</r>"
-          @parser.finish
-          assert(@parser.document.errors.size >= 1)
-          assert_equal "Gau\337", @parser.document.data.join
-          assert_equal [["r"]], @parser.document.end_elements
-        end
-      end
-    end
-  end
-end