psych 2.1.0-java → 2.1.1-java

data/test/psych/nodes/test_enumerable.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: false
-require 'psych/helper'
-
-module Psych
-  module Nodes
-    class TestEnumerable < TestCase
-      def test_includes_enumerable
-        yaml = '--- hello'
-        assert_equal 3, Psych.parse_stream(yaml).to_a.length
-      end
-
-      def test_returns_enumerator
-        yaml = '--- hello'
-        assert_equal 3, Psych.parse_stream(yaml).each.map { |x| x }.length
-      end
-
-      def test_scalar
-        assert_equal 3, calls('--- hello').length
-      end
-
-      def test_sequence
-        assert_equal 4, calls("---\n- hello").length
-      end
-
-      def test_mapping
-        assert_equal 5, calls("---\nhello: world").length
-      end
-
-      def test_alias
-        assert_equal 5, calls("--- &yay\n- foo\n- *yay\n").length
-      end
-
-      private
-
-      def calls yaml
-        calls = []
-        Psych.parse_stream(yaml).each do |node|
-          calls << node
-        end
-        calls
-      end
-    end
-  end
-end

data/test/psych/test_alias_and_anchor.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-
-class ObjectWithInstanceVariables
-  attr_accessor :var1, :var2
-end
-
-class SubStringWithInstanceVariables < String
-  attr_accessor :var1
-end
-
-module Psych
- class TestAliasAndAnchor < TestCase
-   def test_mri_compatibility
-     yaml = <<EOYAML
----
-- &id001 !ruby/object {}
-
-- *id001
-- *id001
-EOYAML
-     result = Psych.load yaml
-     result.each {|el| assert_same(result[0], el) }
-   end
-
-   def test_mri_compatibility_object_with_ivars
-  yaml = <<EOYAML
----
-- &id001 !ruby/object:ObjectWithInstanceVariables
-  var1: test1
-  var2: test2
-- *id001
-- *id001
-EOYAML
-
-     result = Psych.load yaml
-     result.each do |el|
-      assert_same(result[0], el)
-      assert_equal('test1', el.var1)
-      assert_equal('test2', el.var2)
-    end
-   end
-
-   def test_mri_compatibility_substring_with_ivars
-    yaml = <<EOYAML
----
-- &id001 !str:SubStringWithInstanceVariables
-  str: test
-  "@var1": test
-- *id001
-- *id001
-EOYAML
-     result = Psych.load yaml
-     result.each do |el|
-      assert_same(result[0], el)
-      assert_equal('test', el.var1)
-    end
-   end
-
-   def test_anchor_alias_round_trip
-     o = Object.new
-     original = [o,o,o]
-
-     yaml = Psych.dump original
-     result = Psych.load yaml
-     result.each {|el| assert_same(result[0], el) }
-   end
-
-   def test_anchor_alias_round_trip_object_with_ivars
-     o = ObjectWithInstanceVariables.new
-     o.var1 = 'test1'
-     o.var2 = 'test2'
-     original = [o,o,o]
-
-     yaml = Psych.dump original
-     result = Psych.load yaml
-     result.each do |el|
-      assert_same(result[0], el)
-      assert_equal('test1', el.var1)
-      assert_equal('test2', el.var2)
-    end
-   end
-
-   def test_anchor_alias_round_trip_substring_with_ivars
-     o = SubStringWithInstanceVariables.new
-     o.var1 = 'test'
-     original = [o,o,o]
-
-     yaml = Psych.dump original
-     result = Psych.load yaml
-     result.each do |el|
-      assert_same(result[0], el)
-      assert_equal('test', el.var1)
-    end
-   end
- end
-end

data/test/psych/test_array.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-
-module Psych
-  class TestArray < TestCase
-    class X < Array
-    end
-
-    class Y < Array
-      attr_accessor :val
-    end
-
-    def setup
-      super
-      @list = [{ :a => 'b' }, 'foo']
-    end
-
-    def test_another_subclass_with_attributes
-      y = Y.new.tap {|y| y.val = 1}
-      y << "foo" << "bar"
-      y = Psych.load Psych.dump y
-
-      assert_equal %w{foo bar}, y
-      assert_equal Y, y.class
-      assert_equal 1, y.val
-    end
-
-    def test_subclass
-      yaml = Psych.dump X.new
-      assert_match X.name, yaml
-
-      list = X.new
-      list << 1
-      assert_equal X, list.class
-      assert_equal 1, list.first
-    end
-
-    def test_subclass_with_attributes
-      y = Psych.load Psych.dump Y.new.tap {|y| y.val = 1}
-      assert_equal Y, y.class
-      assert_equal 1, y.val
-    end
-
-    def test_backwards_with_syck
-      x = Psych.load "--- !seq:#{X.name} []\n\n"
-      assert_equal X, x.class
-    end
-
-    def test_self_referential
-      @list << @list
-      assert_cycle(@list)
-    end
-
-    def test_cycle
-      assert_cycle(@list)
-    end
-  end
-end

data/test/psych/test_boolean.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-
-module Psych
-  ###
-  # Test booleans from YAML spec:
-  # http://yaml.org/type/bool.html
-  class TestBoolean < TestCase
-    %w{ yes Yes YES true True TRUE on On ON }.each do |truth|
-      define_method(:"test_#{truth}") do
-        assert_equal true, Psych.load("--- #{truth}")
-      end
-    end
-
-    %w{ no No NO false False FALSE off Off OFF }.each do |truth|
-      define_method(:"test_#{truth}") do
-        assert_equal false, Psych.load("--- #{truth}")
-      end
-    end
-
-    ###
-    # YAML spec says "y" and "Y" may be used as true, but Syck treats them
-    # as literal strings
-    def test_y
-      assert_equal "y", Psych.load("--- y")
-      assert_equal "Y", Psych.load("--- Y")
-    end
-
-    ###
-    # YAML spec says "n" and "N" may be used as false, but Syck treats them
-    # as literal strings
-    def test_n
-      assert_equal "n", Psych.load("--- n")
-      assert_equal "N", Psych.load("--- N")
-    end
-  end
-end

data/test/psych/test_class.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-
-module Psych
-  class TestClass < TestCase
-    module Foo
-    end
-
-    def test_cycle_anonymous_class
-      assert_raises(::TypeError) do
-        assert_cycle(Class.new)
-      end
-    end
-
-    def test_cycle_anonymous_module
-      assert_raises(::TypeError) do
-        assert_cycle(Module.new)
-      end
-    end
-
-    def test_cycle
-      assert_cycle(TestClass)
-    end
-
-    def test_dump
-      Psych.dump TestClass
-    end
-
-    def test_cycle_module
-      assert_cycle(Foo)
-    end
-
-    def test_dump_module
-      Psych.dump Foo
-    end
-  end
-end

data/test/psych/test_coder.rb

@@ -1,207 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-
-module Psych
-  class TestCoder < TestCase
-    class InitApi
-      attr_accessor :implicit
-      attr_accessor :style
-      attr_accessor :tag
-      attr_accessor :a, :b, :c
-
-      def initialize
-        @a = 1
-        @b = 2
-        @c = 3
-      end
-
-      def init_with coder
-        @a = coder['aa']
-        @b = coder['bb']
-        @implicit = coder.implicit
-        @tag      = coder.tag
-        @style    = coder.style
-      end
-
-      def encode_with coder
-        coder['aa'] = @a
-        coder['bb'] = @b
-      end
-    end
-
-    class TaggingCoder < InitApi
-      def encode_with coder
-        super
-        coder.tag       = coder.tag.sub(/!/, '!hello')
-        coder.implicit  = false
-        coder.style     = Psych::Nodes::Mapping::FLOW
-      end
-    end
-
-    class ScalarCoder
-      def encode_with coder
-        coder.scalar = "foo"
-      end
-    end
-
-    class Represent
-      yaml_tag 'foo'
-      def encode_with coder
-        coder.represent_scalar 'foo', 'bar'
-      end
-    end
-
-    class RepresentWithInit
-      yaml_tag name
-      attr_accessor :str
-
-      def init_with coder
-        @str = coder.scalar
-      end
-
-      def encode_with coder
-        coder.represent_scalar self.class.name, 'bar'
-      end
-    end
-
-    class RepresentWithSeq
-      yaml_tag name
-      attr_accessor :seq
-
-      def init_with coder
-        @seq = coder.seq
-      end
-
-      def encode_with coder
-        coder.represent_seq self.class.name, %w{ foo bar }
-      end
-    end
-
-    class RepresentWithMap
-      yaml_tag name
-      attr_accessor :map
-
-      def init_with coder
-        @map = coder.map
-      end
-
-      def encode_with coder
-        coder.represent_map self.class.name, { "string" => 'a', :symbol => 'b' }
-      end
-    end
-
-    class RepresentWithObject
-      def encode_with coder
-        coder.represent_object self.class.name, 20
-      end
-    end
-
-    class Referential
-      attr_reader :a
-
-      def initialize
-        @a = self
-      end
-
-      def encode_with(c)
-        c['a'] = @a
-      end
-
-      def init_with(c)
-        @a = c['a']
-      end
-    end
-
-    def test_self_referential
-      x = Referential.new
-      copy = Psych.load Psych.dump x
-      assert_equal copy, copy.a
-    end
-
-    def test_represent_with_object
-      thing = Psych.load(Psych.dump(RepresentWithObject.new))
-      assert_equal 20, thing
-    end
-
-    def test_json_dump_exclude_tag
-      refute_match('TestCoder::InitApi', Psych.to_json(InitApi.new))
-    end
-
-    def test_map_takes_block
-      coder = Psych::Coder.new 'foo'
-      tag = coder.tag
-      style = coder.style
-      coder.map { |map| map.add 'foo', 'bar' }
-      assert_equal 'bar', coder['foo']
-      assert_equal tag, coder.tag
-      assert_equal style, coder.style
-    end
-
-    def test_map_with_tag
-      coder = Psych::Coder.new 'foo'
-      coder.map('hello') { |map| map.add 'foo', 'bar' }
-      assert_equal 'bar', coder['foo']
-      assert_equal 'hello', coder.tag
-    end
-
-    def test_map_with_tag_and_style
-      coder = Psych::Coder.new 'foo'
-      coder.map('hello', 'world') { |map| map.add 'foo', 'bar' }
-      assert_equal 'bar', coder['foo']
-      assert_equal 'hello', coder.tag
-      assert_equal 'world', coder.style
-    end
-
-    def test_represent_map
-      thing = Psych.load(Psych.dump(RepresentWithMap.new))
-      assert_equal({ "string" => 'a', :symbol => 'b' }, thing.map)
-    end
-
-    def test_represent_sequence
-      thing = Psych.load(Psych.dump(RepresentWithSeq.new))
-      assert_equal %w{ foo bar }, thing.seq
-    end
-
-    def test_represent_with_init
-      thing = Psych.load(Psych.dump(RepresentWithInit.new))
-      assert_equal 'bar', thing.str
-    end
-
-    def test_represent!
-      assert_match(/foo/, Psych.dump(Represent.new))
-      assert_instance_of(Represent, Psych.load(Psych.dump(Represent.new)))
-    end
-
-    def test_scalar_coder
-      foo = Psych.load(Psych.dump(ScalarCoder.new))
-      assert_equal 'foo', foo
-    end
-
-    def test_load_dumped_tagging
-      foo = InitApi.new
-      bar = Psych.load(Psych.dump(foo))
-      assert_equal false, bar.implicit
-      assert_equal "!ruby/object:Psych::TestCoder::InitApi", bar.tag
-      assert_equal Psych::Nodes::Mapping::BLOCK, bar.style
-    end
-
-    def test_dump_with_tag
-      foo = TaggingCoder.new
-      assert_match(/hello/, Psych.dump(foo))
-      assert_match(/\{aa/, Psych.dump(foo))
-    end
-
-    def test_dump_encode_with
-      foo = InitApi.new
-      assert_match(/aa/, Psych.dump(foo))
-    end
-
-    def test_dump_init_with
-      foo = InitApi.new
-      bar = Psych.load(Psych.dump(foo))
-      assert_equal foo.a, bar.a
-      assert_equal foo.b, bar.b
-      assert_nil bar.c
-    end
-  end
-end