psych 2.0.14-java

data/test/psych/test_hash.rb

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,65 @@
+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_merge_keys.rb

@@ -0,0 +1,180 @@
+require_relative 'helper'
+
+module Psych
+  class TestMergeKeys < TestCase
+    class Product
+      attr_reader :bar
+    end
+
+    def test_merge_key_with_bare_hash
+      doc = Psych.load <<-eodoc
+map:
+  <<:
+    hello: world
+      eodoc
+      hash = { "map" => { "hello" => "world" } }
+      assert_equal hash, doc
+    end
+
+    def test_roundtrip_with_chevron_key
+      h = {}
+      v = { 'a' => h, '<<' => h }
+      assert_cycle v
+    end
+
+    def test_explicit_string
+      doc = Psych.load <<-eoyml
+a: &me { hello: world }
+b: { !!str '<<': *me }
+eoyml
+      expected = {
+        "a" => { "hello" => "world" },
+        "b" => {
+          "<<" => { "hello" => "world" }
+        }
+      }
+      assert_equal expected, doc
+    end
+
+    def test_mergekey_with_object
+      s = <<-eoyml
+foo: &foo
+  bar: 10
+product:
+  !ruby/object:#{Product.name}
+  <<: *foo
+      eoyml
+      hash = Psych.load s
+      assert_equal({"bar" => 10}, hash["foo"])
+      product = hash["product"]
+      assert_equal 10, product.bar
+    end
+
+    def test_merge_nil
+      yaml = <<-eoyml
+defaults: &defaults
+development:
+  <<: *defaults
+      eoyml
+      assert_equal({'<<' => nil }, Psych.load(yaml)['development'])
+    end
+
+    def test_merge_array
+      yaml = <<-eoyml
+foo: &hello
+- 1
+baz:
+  <<: *hello
+      eoyml
+      assert_equal({'<<' => [1]}, Psych.load(yaml)['baz'])
+    end
+
+    def test_merge_is_not_partial
+      yaml = <<-eoyml
+default: &default
+  hello: world
+foo: &hello
+- 1
+baz:
+  <<: [*hello, *default]
+      eoyml
+      doc = Psych.load yaml
+      refute doc['baz'].key? 'hello'
+      assert_equal({'<<' => [[1], {"hello"=>"world"}]}, Psych.load(yaml)['baz'])
+    end
+
+    def test_merge_seq_nil
+      yaml = <<-eoyml
+foo: &hello
+baz:
+  <<: [*hello]
+      eoyml
+      assert_equal({'<<' => [nil]}, Psych.load(yaml)['baz'])
+    end
+
+    def test_bad_seq_merge
+      yaml = <<-eoyml
+defaults: &defaults [1, 2, 3]
+development:
+  <<: *defaults
+      eoyml
+      assert_equal({'<<' => [1,2,3]}, Psych.load(yaml)['development'])
+    end
+
+    def test_missing_merge_key
+      yaml = <<-eoyml
+bar:
+  << : *foo
+      eoyml
+      exp = assert_raises(Psych::BadAlias) { Psych.load yaml }
+      assert_match 'foo', exp.message
+    end
+
+    # [ruby-core:34679]
+    def test_merge_key
+      yaml = <<-eoyml
+foo: &foo
+  hello: world
+bar:
+  << : *foo
+  baz: boo
+      eoyml
+
+      hash = {
+        "foo" => { "hello" => "world"},
+        "bar" => { "hello" => "world", "baz" => "boo" } }
+      assert_equal hash, Psych.load(yaml)
+    end
+
+    def test_multiple_maps
+      yaml = <<-eoyaml
+---
+- &CENTER { x: 1, y: 2 }
+- &LEFT { x: 0, y: 2 }
+- &BIG { r: 10 }
+- &SMALL { r: 1 }
+
+# All the following maps are equal:
+
+- # Merge multiple maps
+  << : [ *CENTER, *BIG ]
+  label: center/big
+      eoyaml
+
+      hash = {
+        'x' => 1,
+        'y' => 2,
+        'r' => 10,
+        'label' => 'center/big'
+      }
+
+      assert_equal hash, Psych.load(yaml)[4]
+    end
+
+    def test_override
+      yaml = <<-eoyaml
+---
+- &CENTER { x: 1, y: 2 }
+- &LEFT { x: 0, y: 2 }
+- &BIG { r: 10 }
+- &SMALL { r: 1 }
+
+# All the following maps are equal:
+
+- # Override
+  << : [ *BIG, *LEFT, *SMALL ]
+  x: 1
+  label: center/big
+      eoyaml
+
+      hash = {
+        'x' => 1,
+        'y' => 2,
+        'r' => 10,
+        'label' => 'center/big'
+      }
+
+      assert_equal hash, Psych.load(yaml)[4]
+    end
+  end
+end

data/test/psych/test_nil.rb

@@ -0,0 +1,18 @@
+require_relative 'helper'
+
+module Psych
+  class TestNil < TestCase
+    def test_nil
+      yml = Psych.dump nil
+      assert_match(/--- \n(?:\.\.\.\n)?/, yml)
+      assert_nil Psych.load(yml)
+    end
+
+    def test_array_nil
+      yml = Psych.dump [nil]
+      assert_equal "---\n- \n", yml
+      assert_equal [nil], Psych.load(yml)
+    end
+
+  end
+end

data/test/psych/test_null.rb

@@ -0,0 +1,19 @@
+require_relative 'helper'
+
+module Psych
+  ###
+  # Test null from YAML spec:
+  # http://yaml.org/type/null.html
+  class TestNull < TestCase
+    def test_null_list
+      assert_equal [nil] * 5, Psych.load(<<-eoyml)
+---
+- ~
+- null
+-
+- Null
+- NULL
+      eoyml
+    end
+  end
+end

data/test/psych/test_numeric.rb

@@ -0,0 +1,45 @@
+require_relative 'helper'
+require 'bigdecimal'
+
+module Psych
+  ###
+  # Test numerics from YAML spec:
+  # http://yaml.org/type/float.html
+  # http://yaml.org/type/int.html
+  class TestNumeric < TestCase
+    def setup
+      @old_debug = $DEBUG
+      $DEBUG = true
+    end
+
+    def teardown
+      $DEBUG = @old_debug
+    end
+
+    def test_load_float_with_dot
+      assert_equal 1.0, Psych.load('--- 1.')
+    end
+
+    def test_non_float_with_0
+      str = Psych.load('--- 090')
+      assert_equal '090', str
+    end
+
+    def test_big_decimal_tag
+      decimal = BigDecimal("12.34")
+      assert_match "!ruby/object:BigDecimal", Psych.dump(decimal)
+    end
+
+    def test_big_decimal_round_trip
+      decimal = BigDecimal("12.34")
+      assert_cycle decimal
+    end
+
+    def test_does_not_attempt_numeric
+      str = Psych.load('--- 4 roses')
+      assert_equal '4 roses', str
+      str = Psych.load('--- 1.1.1')
+      assert_equal '1.1.1', str
+    end
+  end
+end

data/test/psych/test_object.rb

@@ -0,0 +1,44 @@
+require_relative 'helper'
+
+module Psych
+  class Tagged
+    yaml_tag '!foo'
+
+    attr_accessor :baz
+
+    def initialize
+      @baz = 'bar'
+    end
+  end
+
+  class Foo
+    attr_accessor :parent
+
+    def initialize parent
+      @parent = parent
+    end
+  end
+
+  class TestObject < TestCase
+    def test_dump_with_tag
+      tag = Tagged.new
+      assert_match('foo', Psych.dump(tag))
+    end
+
+    def test_tag_round_trip
+      tag   = Tagged.new
+      tag2  = Psych.load(Psych.dump(tag))
+      assert_equal tag.baz, tag2.baz
+      assert_instance_of(Tagged, tag2)
+    end
+
+    def test_cyclic_references
+      foo = Foo.new(nil)
+      foo.parent = foo
+      loaded = Psych.load Psych.dump foo
+
+      assert_instance_of(Foo, loaded)
+      assert_equal loaded, loaded.parent
+    end
+  end
+end