psych 2.1.0-java → 2.1.1-java

data/test/psych/test_date_time.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-require 'date'
-
-module Psych
-  class TestDateTime < TestCase
-    def test_negative_year
-      time = Time.utc -1, 12, 16
-      assert_cycle time
-    end
-
-    def test_new_datetime
-      assert_cycle DateTime.new
-    end
-
-    def test_invalid_date
-      assert_cycle "2013-10-31T10:40:07-000000000000033"
-    end
-
-    def test_string_tag
-      dt = DateTime.now
-      yaml = Psych.dump dt
-      assert_match(/DateTime/, yaml)
-    end
-
-    def test_round_trip
-      dt = DateTime.now
-      assert_cycle dt
-    end
-
-    def test_alias_with_time
-      t    = Time.now
-      h    = {:a => t, :b => t}
-      yaml = Psych.dump h
-      assert_match('&', yaml)
-      assert_match('*', yaml)
-    end
-  end
-end

data/test/psych/test_deprecated.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-
-module Psych
-  class TestDeprecated < TestCase
-    def teardown
-      $VERBOSE = @orig_verbose
-      Psych.domain_types.clear
-    end
-
-    class QuickEmitter
-      attr_reader :name
-      attr_reader :value
-
-      def initialize
-        @name  = 'hello!!'
-        @value = 'Friday!'
-      end
-
-      def to_yaml opts = {}
-        Psych.quick_emit object_id, opts do |out|
-          out.map taguri, to_yaml_style do |map|
-            map.add 'name', @name
-            map.add 'value', nil
-          end
-        end
-      end
-    end
-
-    def setup
-      @qe = QuickEmitter.new
-      @orig_verbose, $VERBOSE = $VERBOSE, false
-    end
-
-    def test_quick_emit
-      qe2 = Psych.load @qe.to_yaml
-      assert_equal @qe.name, qe2.name
-      assert_instance_of QuickEmitter, qe2
-      assert_nil qe2.value
-    end
-
-    def test_recursive_quick_emit
-      hash  = { :qe => @qe }
-      hash2 = Psych.load Psych.dump hash
-      qe    = hash2[:qe]
-
-      assert_equal @qe.name, qe.name
-      assert_instance_of QuickEmitter, qe
-      assert_nil qe.value
-    end
-
-    class QuickEmitterEncodeWith
-      attr_reader :name
-      attr_reader :value
-
-      def initialize
-        @name  = 'hello!!'
-        @value = 'Friday!'
-      end
-
-      def encode_with coder
-        coder.map do |map|
-          map.add 'name', @name
-          map.add 'value', nil
-        end
-      end
-
-      def to_yaml opts = {}
-        raise
-      end
-    end
-
-    ###
-    # An object that defines both to_yaml and encode_with should only call
-    # encode_with.
-    def test_recursive_quick_emit_encode_with
-      qeew = QuickEmitterEncodeWith.new
-      hash  = { :qe => qeew }
-      hash2 = Psych.load Psych.dump hash
-      qe    = hash2[:qe]
-
-      assert_equal qeew.name, qe.name
-      assert_instance_of QuickEmitterEncodeWith, qe
-      assert_nil qe.value
-    end
-
-    class YamlInit
-      attr_reader :name
-      attr_reader :value
-
-      def initialize
-        @name  = 'hello!!'
-        @value = 'Friday!'
-      end
-
-      def yaml_initialize tag, vals
-        vals.each { |ivar, val| instance_variable_set "@#{ivar}", 'TGIF!' }
-      end
-    end
-
-    def test_yaml_initialize
-      hash  = { :yi => YamlInit.new }
-      hash2 = Psych.load Psych.dump hash
-      yi    = hash2[:yi]
-
-      assert_equal 'TGIF!', yi.name
-      assert_equal 'TGIF!', yi.value
-      assert_instance_of YamlInit, yi
-    end
-
-    class YamlInitAndInitWith
-      attr_reader :name
-      attr_reader :value
-
-      def initialize
-        @name  = 'shaners'
-        @value = 'Friday!'
-      end
-
-      def init_with coder
-        coder.map.each { |ivar, val| instance_variable_set "@#{ivar}", 'TGIF!' }
-      end
-
-      def yaml_initialize tag, vals
-        raise
-      end
-    end
-
-    ###
-    # An object that implements both yaml_initialize and init_with should not
-    # receive the yaml_initialize call.
-    def test_yaml_initialize_and_init_with
-      hash  = { :yi => YamlInitAndInitWith.new }
-      hash2 = Psych.load Psych.dump hash
-      yi    = hash2[:yi]
-
-      assert_equal 'TGIF!', yi.name
-      assert_equal 'TGIF!', yi.value
-      assert_instance_of YamlInitAndInitWith, yi
-    end
-
-    def test_coder_scalar
-      coder = Psych::Coder.new 'foo'
-      coder.scalar('tag', 'some string', :plain)
-      assert_equal 'tag', coder.tag
-      assert_equal 'some string', coder.scalar
-      assert_equal :scalar, coder.type
-    end
-
-    class YamlAs
-      TestCase.suppress_warning do
-        psych_yaml_as 'helloworld' # this should be yaml_as but to avoid syck
-      end
-    end
-
-    def test_yaml_as
-      assert_match(/helloworld/, Psych.dump(YamlAs.new))
-    end
-
-    def test_ruby_type
-      types = []
-      appender = lambda { |*args| types << args }
-
-      Psych.add_ruby_type('foo', &appender)
-      Psych.load <<-eoyml
-- !ruby.yaml.org,2002/foo bar
-      eoyml
-
-      assert_equal [["tag:ruby.yaml.org,2002:foo", "bar"]], types
-    end
-
-    def test_detect_implicit
-      assert_equal '', Psych.detect_implicit(nil)
-      assert_equal '', Psych.detect_implicit(Object.new)
-      assert_equal '', Psych.detect_implicit(1.2)
-      assert_equal 'null', Psych.detect_implicit('')
-      assert_equal 'string', Psych.detect_implicit('foo')
-    end
-
-    def test_private_type
-      types = []
-      Psych.add_private_type('foo') { |*args| types << args }
-      Psych.load <<-eoyml
-- !x-private:foo bar
-      eoyml
-
-      assert_equal [["x-private:foo", "bar"]], types
-    end
-
-    def test_tagurize
-      assert_nil Psych.tagurize nil
-      assert_equal Psych, Psych.tagurize(Psych)
-      assert_equal 'tag:yaml.org,2002:foo', Psych.tagurize('foo')
-    end
-
-    def test_read_type_class
-      things = Psych.read_type_class 'tag:yaml.org,2002:int:Psych::TestDeprecated::QuickEmitter', Object
-      assert_equal 'int', things.first
-      assert_equal Psych::TestDeprecated::QuickEmitter, things.last
-    end
-
-    def test_read_type_class_no_class
-      things = Psych.read_type_class 'tag:yaml.org,2002:int', Object
-      assert_equal 'int', things.first
-      assert_equal Object, things.last
-    end
-
-    def test_object_maker
-      thing = Psych.object_maker(Object, { 'a' => 'b', 'c' => 'd' })
-      assert_instance_of(Object, thing)
-      assert_equal 'b', thing.instance_variable_get(:@a)
-      assert_equal 'd', thing.instance_variable_get(:@c)
-    end
-  end
-end

data/test/psych/test_document.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-
-module Psych
-  class TestDocument < TestCase
-    def setup
-      super
-      @stream = Psych.parse_stream(<<-eoyml)
-%YAML 1.1
-%TAG ! tag:tenderlovemaking.com,2009:
---- !fun
-      eoyml
-      @doc = @stream.children.first
-    end
-
-    def test_parse_tag
-      assert_equal([['!', 'tag:tenderlovemaking.com,2009:']],
-        @doc.tag_directives)
-    end
-
-    def test_emit_tag
-      assert_match('%TAG ! tag:tenderlovemaking.com,2009:', @stream.yaml)
-    end
-
-    def test_emit_multitag
-      @doc.tag_directives << ['!!', 'foo.com,2009:']
-      yaml = @stream.yaml
-      assert_match('%TAG ! tag:tenderlovemaking.com,2009:', yaml)
-      assert_match('%TAG !! foo.com,2009:', yaml)
-    end
-
-    def test_emit_bad_tag
-      assert_raises(RuntimeError) do
-        @doc.tag_directives = [['!']]
-        @stream.yaml
-      end
-    end
-
-    def test_parse_version
-      assert_equal([1,1], @doc.version)
-    end
-
-    def test_emit_version
-      assert_match('%YAML 1.1', @stream.yaml)
-    end
-  end
-end

data/test/psych/test_emitter.rb

@@ -1,112 +0,0 @@
-# -*- coding: utf-8 -*-
-# frozen_string_literal: false
-
-require_relative 'helper'
-
-module Psych
-  class TestEmitter < TestCase
-    def setup
-      super
-      @out = StringIO.new('')
-      @emitter = Psych::Emitter.new @out
-    end
-
-    def test_line_width
-      @emitter.line_width = 10
-      assert_equal 10, @emitter.line_width
-    end
-
-    def test_set_canonical
-      @emitter.canonical = true
-      assert_equal true, @emitter.canonical
-
-      @emitter.canonical = false
-      assert_equal false, @emitter.canonical
-    end
-
-    def test_indentation_set
-      assert_equal 2, @emitter.indentation
-      @emitter.indentation = 5
-      assert_equal 5, @emitter.indentation
-    end
-
-    def test_emit_utf_8
-      @emitter.start_stream Psych::Nodes::Stream::UTF8
-      @emitter.start_document [], [], false
-      @emitter.scalar '日本語', nil, nil, false, true, 1
-      @emitter.end_document true
-      @emitter.end_stream
-      assert_match('日本語', @out.string)
-    end
-
-    def test_start_stream_arg_error
-      assert_raises(TypeError) do
-        @emitter.start_stream 'asdfasdf'
-      end
-    end
-
-    def test_start_doc_arg_error
-      @emitter.start_stream Psych::Nodes::Stream::UTF8
-
-      [
-        [nil, [], false],
-        [[nil, nil], [], false],
-        [[], 'foo', false],
-        [[], ['foo'], false],
-        [[], [nil,nil], false],
-        [[1,1], [[nil, "tag:TALOS"]], 0],
-      ].each do |args|
-        assert_raises(TypeError) do
-          @emitter.start_document(*args)
-        end
-      end
-    end
-
-    def test_scalar_arg_error
-      @emitter.start_stream Psych::Nodes::Stream::UTF8
-      @emitter.start_document [], [], false
-
-      [
-        [:foo, nil, nil, false, true, 1],
-        ['foo', Object.new, nil, false, true, 1],
-        ['foo', nil, Object.new, false, true, 1],
-        ['foo', nil, nil, false, true, :foo],
-        [nil, nil, nil, false, true, 1],
-      ].each do |args|
-        assert_raises(TypeError) do
-          @emitter.scalar(*args)
-        end
-      end
-    end
-
-    def test_start_sequence_arg_error
-      @emitter.start_stream Psych::Nodes::Stream::UTF8
-      @emitter.start_document [], [], false
-
-      assert_raises(TypeError) do
-        @emitter.start_sequence(nil, Object.new, true, 1)
-      end
-
-      assert_raises(TypeError) do
-        @emitter.start_sequence(nil, nil, true, :foo)
-      end
-    end
-
-    def test_resizing_tags
-      @emitter.start_stream Psych::Nodes::Stream::UTF8
-
-      tags = []
-      version = [1,1]
-      obj = Object.new
-      obj.instance_variable_set(:@tags, tags)
-      def obj.to_str
-        (1..10).map{|x| @tags.push(["AAAA","BBBB"])}
-        return "x"
-      end
-
-      tags.push([obj, "tag:TALOS"])
-      @emitter.start_document(version, tags, 0)
-      assert(true)
-    end
-  end
-end

data/test/psych/test_encoding.rb

@@ -1,269 +0,0 @@
-# -*- coding: utf-8 -*-
-# frozen_string_literal: false
-
-require_relative 'helper'
-
-module Psych
-  class TestEncoding < TestCase
-    class EncodingCatcher < Handler
-      attr_reader :strings
-      def initialize
-        @strings = []
-      end
-
-      (Handler.instance_methods(true) -
-       Object.instance_methods).each do |m|
-        class_eval %{
-          def #{m} *args
-            @strings += args.flatten.find_all { |a|
-              String === a
-            }
-          end
-        }
-      end
-    end
-
-    def setup
-      super
-      @buffer  = StringIO.new
-      @handler = EncodingCatcher.new
-      @parser  = Psych::Parser.new @handler
-      @utf8    = Encoding.find('UTF-8')
-      @emitter = Psych::Emitter.new @buffer
-    end
-
-    def test_dump_load_encoding_object
-      assert_cycle Encoding::US_ASCII
-      assert_cycle Encoding::UTF_8
-    end
-
-    def test_transcode_shiftjis
-      str = "こんにちは！"
-      loaded = Psych.load("--- こんにちは！".encode('SHIFT_JIS'))
-      assert_equal str, loaded
-    end
-
-    def test_transcode_utf16le
-      str = "こんにちは！"
-      loaded = Psych.load("--- こんにちは！".encode('UTF-16LE'))
-      assert_equal str, loaded
-    end
-
-    def test_transcode_utf16be
-      str = "こんにちは！"
-      loaded = Psych.load("--- こんにちは！".encode('UTF-16BE'))
-      assert_equal str, loaded
-    end
-
-    def test_io_shiftjis
-      Tempfile.create(['shiftjis', 'yml'], :encoding => 'SHIFT_JIS') {|t|
-        t.write '--- こんにちは！'
-        t.close
-
-        # If the external encoding isn't utf8, utf16le, or utf16be, we cannot
-        # process the file.
-        File.open(t.path, 'r', :encoding => 'SHIFT_JIS') do |f|
-          assert_raises Psych::SyntaxError do
-            Psych.load(f)
-          end
-        end
-      }
-    end
-
-    def test_io_utf16le
-      Tempfile.create(['utf16le', 'yml']) {|t|
-        t.binmode
-        t.write '--- こんにちは！'.encode('UTF-16LE')
-        t.close
-
-        File.open(t.path, 'rb', :encoding => 'UTF-16LE') do |f|
-          assert_equal "こんにちは！", Psych.load(f)
-        end
-      }
-    end
-
-    def test_io_utf16be
-      Tempfile.create(['utf16be', 'yml']) {|t|
-        t.binmode
-        t.write '--- こんにちは！'.encode('UTF-16BE')
-        t.close
-
-        File.open(t.path, 'rb', :encoding => 'UTF-16BE') do |f|
-          assert_equal "こんにちは！", Psych.load(f)
-        end
-      }
-    end
-
-    def test_io_utf8
-      Tempfile.create(['utf8', 'yml']) {|t|
-        t.binmode
-        t.write '--- こんにちは！'.encode('UTF-8')
-        t.close
-
-        File.open(t.path, 'rb', :encoding => 'UTF-8') do |f|
-          assert_equal "こんにちは！", Psych.load(f)
-        end
-      }
-    end
-
-    def test_emit_alias
-      @emitter.start_stream Psych::Parser::UTF8
-      @emitter.start_document [], [], true
-      e = assert_raises(RuntimeError) do
-        @emitter.alias 'ドラえもん'.encode('EUC-JP')
-      end
-      assert_match(/alias value/, e.message)
-    end
-
-    def test_to_yaml_is_valid
-      with_default_external(Encoding::US_ASCII) do
-        with_default_internal(nil) do
-          s = "こんにちは！"
-          # If no encoding is specified, use UTF-8
-          assert_equal Encoding::UTF_8, Psych.dump(s).encoding
-          assert_equal s, Psych.load(Psych.dump(s))
-        end
-      end
-    end
-
-    def test_start_mapping
-      foo = 'foo'
-      bar = 'バー'
-
-      @emitter.start_stream Psych::Parser::UTF8
-      @emitter.start_document [], [], true
-      @emitter.start_mapping(
-        foo.encode('Shift_JIS'),
-        bar.encode('UTF-16LE'),
-        false, Nodes::Sequence::ANY)
-      @emitter.end_mapping
-      @emitter.end_document false
-      @emitter.end_stream
-
-      @parser.parse @buffer.string
-      assert_encodings @utf8, @handler.strings
-      assert_equal [foo, bar], @handler.strings
-    end
-
-    def test_start_sequence
-      foo = 'foo'
-      bar = 'バー'
-
-      @emitter.start_stream Psych::Parser::UTF8
-      @emitter.start_document [], [], true
-      @emitter.start_sequence(
-        foo.encode('Shift_JIS'),
-        bar.encode('UTF-16LE'),
-        false, Nodes::Sequence::ANY)
-      @emitter.end_sequence
-      @emitter.end_document false
-      @emitter.end_stream
-
-      @parser.parse @buffer.string
-      assert_encodings @utf8, @handler.strings
-      assert_equal [foo, bar], @handler.strings
-    end
-
-    def test_doc_tag_encoding
-      key = '鍵'
-      @emitter.start_stream Psych::Parser::UTF8
-      @emitter.start_document(
-        [1, 1],
-        [['!'.encode('EUC-JP'), key.encode('EUC-JP')]],
-        true
-      )
-      @emitter.scalar 'foo', nil, nil, true, false, Nodes::Scalar::ANY
-      @emitter.end_document false
-      @emitter.end_stream
-
-      @parser.parse @buffer.string
-      assert_encodings @utf8, @handler.strings
-      assert_equal key, @handler.strings[1]
-    end
-
-    def test_emitter_encoding
-      str  = "壁に耳あり、障子に目あり"
-      thing = Psych.load Psych.dump str.encode('EUC-JP')
-      assert_equal str, thing
-    end
-
-    def test_default_internal
-      with_default_internal(Encoding::EUC_JP) do
-        str  = "壁に耳あり、障子に目あり"
-        assert_equal @utf8, str.encoding
-
-        @parser.parse str
-        assert_encodings Encoding::EUC_JP, @handler.strings
-        assert_equal str, @handler.strings.first.encode('UTF-8')
-      end
-    end
-
-    def test_scalar
-      @parser.parse("--- a")
-      assert_encodings @utf8, @handler.strings
-    end
-
-    def test_alias
-      @parser.parse(<<-eoyml)
-%YAML 1.1
----
-!!seq [
-  !!str "Without properties",
-  &A !!str "Anchored",
-  !!str "Tagged",
-  *A,
-  !!str "",
-]
-      eoyml
-      assert_encodings @utf8, @handler.strings
-    end
-
-    def test_list_anchor
-      list = %w{ a b }
-      list << list
-      @parser.parse(Psych.dump(list))
-      assert_encodings @utf8, @handler.strings
-    end
-
-    def test_map_anchor
-      h = {}
-      h['a'] = h
-      @parser.parse(Psych.dump(h))
-      assert_encodings @utf8, @handler.strings
-    end
-
-    def test_map_tag
-      @parser.parse(<<-eoyml)
-%YAML 1.1
----
-!!map { a : b }
-      eoyml
-      assert_encodings @utf8, @handler.strings
-    end
-
-    def test_doc_tag
-      @parser.parse(<<-eoyml)
-%YAML 1.1
-%TAG ! tag:tenderlovemaking.com,2009:
---- !fun
-      eoyml
-      assert_encodings @utf8, @handler.strings
-    end
-
-    def test_dump_non_ascii_string_to_file
-      Tempfile.create(['utf8', 'yml'], :encoding => 'UTF-8') do |t|
-        h = {'one' => 'いち'}
-        Psych.dump(h, t)
-        t.close
-        assert_equal h, Psych.load_file(t.path)
-      end
-    end
-
-    private
-    def assert_encodings encoding, strings
-      strings.each do |str|
-        assert_equal encoding, str.encoding, str
-      end
-    end
-  end
-end