psych 2.0.12 → 5.2.3

data/test/psych/test_encoding.rb

@@ -1,259 +0,0 @@
-# -*- coding: utf-8 -*-
-
-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
-
-    private
-    def assert_encodings encoding, strings
-      strings.each do |str|
-        assert_equal encoding, str.encoding, str
-      end
-    end
-  end
-end

data/test/psych/test_exception.rb

@@ -1,157 +0,0 @@
-require_relative 'helper'
-
-module Psych
-  class TestException < TestCase
-    class Wups < Exception
-      attr_reader :foo, :bar
-      def initialize *args
-        super
-        @foo = 1
-        @bar = 2
-      end
-    end
-
-    def setup
-      super
-      @wups = Wups.new
-    end
-
-    def test_naming_exception
-      err     = String.xxx rescue $!
-      new_err = Psych.load(Psych.dump(err))
-      assert_equal err.message, new_err.message
-    end
-
-    def test_load_takes_file
-      ex = assert_raises(Psych::SyntaxError) do
-        Psych.load '--- `'
-      end
-      assert_nil ex.file
-
-      ex = assert_raises(Psych::SyntaxError) do
-        Psych.load '--- `', 'meow'
-      end
-      assert_equal 'meow', ex.file
-    end
-
-    def test_psych_parse_stream_takes_file
-      ex = assert_raises(Psych::SyntaxError) do
-        Psych.parse_stream '--- `'
-      end
-      assert_nil ex.file
-      assert_match '(<unknown>)', ex.message
-
-      ex = assert_raises(Psych::SyntaxError) do
-        Psych.parse_stream '--- `', 'omg!'
-      end
-      assert_equal 'omg!', ex.file
-      assert_match 'omg!', ex.message
-    end
-
-    def test_load_stream_takes_file
-      ex = assert_raises(Psych::SyntaxError) do
-        Psych.load_stream '--- `'
-      end
-      assert_nil ex.file
-      assert_match '(<unknown>)', ex.message
-
-      ex = assert_raises(Psych::SyntaxError) do
-        Psych.load_stream '--- `', 'omg!'
-      end
-      assert_equal 'omg!', ex.file
-    end
-
-    def test_parse_file_exception
-      Tempfile.create(['parsefile', 'yml']) {|t|
-        t.binmode
-        t.write '--- `'
-        t.close
-        ex = assert_raises(Psych::SyntaxError) do
-          Psych.parse_file t.path
-        end
-        assert_equal t.path, ex.file
-      }
-    end
-
-    def test_load_file_exception
-      Tempfile.create(['loadfile', 'yml']) {|t|
-        t.binmode
-        t.write '--- `'
-        t.close
-        ex = assert_raises(Psych::SyntaxError) do
-          Psych.load_file t.path
-        end
-        assert_equal t.path, ex.file
-      }
-    end
-
-    def test_psych_parse_takes_file
-      ex = assert_raises(Psych::SyntaxError) do
-        Psych.parse '--- `'
-      end
-      assert_match '(<unknown>)', ex.message
-      assert_nil ex.file
-
-      ex = assert_raises(Psych::SyntaxError) do
-        Psych.parse '--- `', 'omg!'
-      end
-      assert_match 'omg!', ex.message
-    end
-
-    def test_attributes
-      e = assert_raises(Psych::SyntaxError) {
-        Psych.load '--- `foo'
-      }
-
-      assert_nil e.file
-      assert_equal 1, e.line
-      assert_equal 5, e.column
-      # FIXME: offset isn't being set correctly by libyaml
-      # assert_equal 5, e.offset
-
-      assert e.problem
-      assert e.context
-    end
-
-    def test_convert
-      w = Psych.load(Psych.dump(@wups))
-      assert_equal @wups, w
-      assert_equal 1, w.foo
-      assert_equal 2, w.bar
-    end
-
-    def test_to_yaml_properties
-      class << @wups
-        def to_yaml_properties
-          [:@foo]
-        end
-      end
-
-      w = Psych.load(Psych.dump(@wups))
-      assert_equal @wups, w
-      assert_equal 1, w.foo
-      assert_nil w.bar
-    end
-
-    def test_psych_syntax_error
-      Tempfile.create(['parsefile', 'yml']) do |t|
-        t.binmode
-        t.write '--- `'
-        t.close
-
-        begin
-          Psych.parse_file t.path
-        rescue StandardError
-          assert true # count assertion
-        ensure
-          return unless $!
-
-          ancestors = $!.class.ancestors.inspect
-
-          flunk "Psych::SyntaxError not rescued by StandardError: #{ancestors}"
-        end
-      end
-    end
-
-  end
-end

data/test/psych/test_hash.rb

@@ -1,94 +0,0 @@
-require_relative 'helper'
-
-module Psych
-  class TestHash < TestCase
-    class X < Hash
-    end
-
-    class HashWithCustomInit < Hash
-      attr_reader :obj
-      def initialize(obj)
-        @obj = obj
-      end
-    end
-
-    class HashWithCustomInitNoIvar < Hash
-      def initialize(obj)
-        # *shrug*
-      end
-    end
-
-    def setup
-      super
-      @hash = { :a => 'b' }
-    end
-
-    def test_referenced_hash_with_ivar
-      a = [1,2,3,4,5]
-      t1 = [HashWithCustomInit.new(a)]
-      t1 << t1.first
-      assert_cycle t1
-    end
-
-    def test_custom_initialized
-      a = [1,2,3,4,5]
-      t1 = HashWithCustomInit.new(a)
-      t2 = Psych.load(Psych.dump(t1))
-      assert_equal t1, t2
-      assert_cycle t1
-    end
-
-    def test_custom_initialize_no_ivar
-      t1 = HashWithCustomInitNoIvar.new(nil)
-      t2 = Psych.load(Psych.dump(t1))
-      assert_equal t1, t2
-      assert_cycle t1
-    end
-
-    def test_hash_subclass_with_ivars
-      x = X.new
-      x[:a] = 'b'
-      x.instance_variable_set :@foo, 'bar'
-      dup = Psych.load Psych.dump x
-      assert_cycle x
-      assert_equal 'bar', dup.instance_variable_get(:@foo)
-      assert_equal X, dup.class
-    end
-
-    def test_load_with_class_syck_compatibility
-      hash = Psych.load "--- !ruby/object:Hash\n:user_id: 7\n:username: Lucas\n"
-      assert_equal({ user_id: 7, username: 'Lucas'}, hash)
-    end
-
-    def test_empty_subclass
-      assert_match "!ruby/hash:#{X}", Psych.dump(X.new)
-      x = Psych.load Psych.dump X.new
-      assert_equal X, x.class
-    end
-
-    def test_map
-      x = Psych.load "--- !map:#{X} { }\n"
-      assert_equal X, x.class
-    end
-
-    def test_self_referential
-      @hash['self'] = @hash
-      assert_cycle(@hash)
-    end
-
-    def test_cycles
-      assert_cycle(@hash)
-    end
-
-    def test_ref_append
-      hash = Psych.load(<<-eoyml)
----
-foo: &foo
-  hello: world
-bar:
-  <<: *foo
-eoyml
-      assert_equal({"foo"=>{"hello"=>"world"}, "bar"=>{"hello"=>"world"}}, hash)
-    end
-  end
-end

data/test/psych/test_json_tree.rb

@@ -1,65 +0,0 @@
-require_relative 'helper'
-
-module Psych
-  class TestJSONTree < TestCase
-    def test_string
-      assert_match(/"foo"/, Psych.to_json("foo"))
-    end
-
-    def test_symbol
-      assert_match(/"foo"/, Psych.to_json(:foo))
-    end
-
-    def test_nil
-      assert_match(/^null/, Psych.to_json(nil))
-    end
-
-    def test_int
-      assert_match(/^10/, Psych.to_json(10))
-    end
-
-    def test_float
-      assert_match(/^1.2/, Psych.to_json(1.2))
-    end
-
-    def test_hash
-      hash = { 'one' => 'two' }
-      json = Psych.to_json(hash)
-      assert_match(/}$/, json)
-      assert_match(/^\{/, json)
-      assert_match(/['"]one['"]/, json)
-      assert_match(/['"]two['"]/, json)
-    end
-
-    class Bar
-      def encode_with coder
-        coder.represent_seq 'omg', %w{ a b c }
-      end
-    end
-
-    def test_json_list_dump_exclude_tag
-      json = Psych.to_json Bar.new
-      refute_match('omg', json)
-    end
-
-    def test_list_to_json
-      list = %w{ one two }
-      json = Psych.to_json(list)
-      assert_match(/\]$/, json)
-      assert_match(/^\[/, json)
-      assert_match(/"one"/, json)
-      assert_match(/"two"/, json)
-    end
-
-    def test_time
-      time = Time.utc(2010, 10, 10)
-      assert_equal "{\"a\": \"2010-10-10 00:00:00.000000000 Z\"}\n",
-Psych.to_json({'a' => time })
-    end
-
-    def test_datetime
-      time = Time.new(2010, 10, 10).to_datetime
-      assert_equal "{\"a\": \"#{time.strftime("%Y-%m-%d %H:%M:%S.%9N %:z")}\"}\n", Psych.to_json({'a' => time })
-    end
-  end
-end

data/test/psych/test_marshalable.rb

@@ -1,54 +0,0 @@
-require_relative 'helper'
-require 'delegate'
-
-module Psych
-  class TestMarshalable < TestCase
-    def test_objects_defining_marshal_dump_and_marshal_load_can_be_dumped
-      sd = SimpleDelegator.new(1)
-      loaded = Psych.load(Psych.dump(sd))
-
-      assert_instance_of(SimpleDelegator, loaded)
-      assert_equal(sd, loaded)
-    end
-
-    class PsychCustomMarshalable < BasicObject
-      attr_reader :foo
-
-      def initialize(foo)
-        @foo = foo
-      end
-
-      def marshal_dump
-        [foo]
-      end
-
-      def mashal_load(data)
-        @foo = data[0]
-      end
-
-      def init_with(coder)
-        @foo = coder['foo']
-      end
-
-      def encode_with(coder)
-        coder['foo'] = 2
-      end
-
-      def respond_to?(method)
-        [:marshal_dump, :marshal_load, :init_with, :encode_with].include?(method)
-      end
-
-      def class
-        PsychCustomMarshalable
-      end
-    end
-
-    def test_init_with_takes_priority_over_marshal_methods
-      obj = PsychCustomMarshalable.new(1)
-      loaded = Psych.load(Psych.dump(obj))
-
-      assert(PsychCustomMarshalable === loaded)
-      assert_equal(2, loaded.foo)
-    end
-  end
-end