mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
Bump psych version to 3.3.2
This commit is contained in:
parent
5a6f8462dc
commit
5afefe4371
41 changed files with 377 additions and 218 deletions
|
@ -271,7 +271,7 @@ module Psych
|
|||
# YAML documents that are supplied via user input. Instead, please use the
|
||||
# safe_load method.
|
||||
#
|
||||
def self.load yaml, legacy_filename = NOT_GIVEN, filename: nil, fallback: false, symbolize_names: false, freeze: false
|
||||
def self.unsafe_load yaml, legacy_filename = NOT_GIVEN, filename: nil, fallback: false, symbolize_names: false, freeze: false
|
||||
if legacy_filename != NOT_GIVEN
|
||||
warn_with_uplevel 'Passing filename with the 2nd argument of Psych.load is deprecated. Use keyword argument like Psych.load(yaml, filename: ...) instead.', uplevel: 1 if $VERBOSE
|
||||
filename = legacy_filename
|
||||
|
@ -281,6 +281,7 @@ module Psych
|
|||
return fallback unless result
|
||||
result.to_ruby(symbolize_names: symbolize_names, freeze: freeze)
|
||||
end
|
||||
class << self; alias :load :unsafe_load; end
|
||||
|
||||
###
|
||||
# Safely load the yaml string in +yaml+. By default, only the following
|
||||
|
@ -577,11 +578,12 @@ module Psych
|
|||
# NOTE: This method *should not* be used to parse untrusted documents, such as
|
||||
# YAML documents that are supplied via user input. Instead, please use the
|
||||
# safe_load_file method.
|
||||
def self.load_file filename, **kwargs
|
||||
def self.unsafe_load_file filename, **kwargs
|
||||
File.open(filename, 'r:bom|utf-8') { |f|
|
||||
self.load f, filename: filename, **kwargs
|
||||
self.unsafe_load f, filename: filename, **kwargs
|
||||
}
|
||||
end
|
||||
class << self; alias :load_file :unsafe_load_file; end
|
||||
|
||||
###
|
||||
# Safely loads the document contained in +filename+. Returns the yaml contained in
|
||||
|
|
|
@ -119,7 +119,7 @@ module Psych
|
|||
# +tag+ is an associated tag or nil
|
||||
# +plain+ is a boolean value
|
||||
# +quoted+ is a boolean value
|
||||
# +style+ is an integer idicating the string style
|
||||
# +style+ is an integer indicating the string style
|
||||
#
|
||||
# See the constants in Psych::Nodes::Scalar for the possible values of
|
||||
# +style+
|
||||
|
|
|
@ -50,7 +50,7 @@ module Psych
|
|||
# +tag+ is an associated tag or nil
|
||||
# +plain+ is a boolean value
|
||||
# +quoted+ is a boolean value
|
||||
# +style+ is an integer idicating the string style
|
||||
# +style+ is an integer indicating the string style
|
||||
#
|
||||
# == See Also
|
||||
#
|
||||
|
|
|
@ -1,10 +1,10 @@
|
|||
|
||||
# frozen_string_literal: true
|
||||
|
||||
module Psych
|
||||
# The version of Psych you are using
|
||||
VERSION = '3.3.0'
|
||||
VERSION = '3.3.2'
|
||||
|
||||
if RUBY_ENGINE == 'jruby'
|
||||
DEFAULT_SNAKEYAML_VERSION = '1.26'.freeze
|
||||
DEFAULT_SNAKEYAML_VERSION = '1.28'.freeze
|
||||
end
|
||||
end
|
||||
|
|
|
@ -24,6 +24,7 @@ module Psych
|
|||
super()
|
||||
@st = {}
|
||||
@ss = ss
|
||||
@load_tags = Psych.load_tags
|
||||
@domain_types = Psych.domain_types
|
||||
@class_loader = class_loader
|
||||
@symbolize_names = symbolize_names
|
||||
|
@ -48,7 +49,7 @@ module Psych
|
|||
end
|
||||
|
||||
def deserialize o
|
||||
if klass = resolve_class(Psych.load_tags[o.tag])
|
||||
if klass = resolve_class(@load_tags[o.tag])
|
||||
instance = klass.allocate
|
||||
|
||||
if instance.respond_to?(:init_with)
|
||||
|
@ -128,7 +129,7 @@ module Psych
|
|||
end
|
||||
|
||||
def visit_Psych_Nodes_Sequence o
|
||||
if klass = resolve_class(Psych.load_tags[o.tag])
|
||||
if klass = resolve_class(@load_tags[o.tag])
|
||||
instance = klass.allocate
|
||||
|
||||
if instance.respond_to?(:init_with)
|
||||
|
@ -160,8 +161,8 @@ module Psych
|
|||
end
|
||||
|
||||
def visit_Psych_Nodes_Mapping o
|
||||
if Psych.load_tags[o.tag]
|
||||
return revive(resolve_class(Psych.load_tags[o.tag]), o)
|
||||
if @load_tags[o.tag]
|
||||
return revive(resolve_class(@load_tags[o.tag]), o)
|
||||
end
|
||||
return revive_hash(register(o, {}), o) unless o.tag
|
||||
|
||||
|
@ -326,6 +327,7 @@ module Psych
|
|||
end
|
||||
|
||||
private
|
||||
|
||||
def register node, object
|
||||
@st[node.anchor] = object if node.anchor
|
||||
object
|
||||
|
@ -337,7 +339,7 @@ module Psych
|
|||
list
|
||||
end
|
||||
|
||||
def revive_hash hash, o
|
||||
def revive_hash hash, o, tagged= false
|
||||
o.children.each_slice(2) { |k,v|
|
||||
key = accept(k)
|
||||
val = accept(v)
|
||||
|
@ -364,7 +366,7 @@ module Psych
|
|||
hash[key] = val
|
||||
end
|
||||
else
|
||||
if @symbolize_names
|
||||
if !tagged && @symbolize_names && key.is_a?(String)
|
||||
key = key.to_sym
|
||||
elsif !@freeze
|
||||
key = deduplicate(key)
|
||||
|
@ -402,7 +404,7 @@ module Psych
|
|||
|
||||
def revive klass, node
|
||||
s = register(node, klass.allocate)
|
||||
init_with(s, revive_hash({}, node), node)
|
||||
init_with(s, revive_hash({}, node, true), node)
|
||||
end
|
||||
|
||||
def init_with o, h, node
|
||||
|
|
|
@ -17,7 +17,7 @@ module Psych
|
|||
|
||||
if defined?(Ractor)
|
||||
def dispatch
|
||||
Ractor.current[:Psych_Visitors_Visitor] ||= Visitor.dispatch_cache
|
||||
@dispatch_cache ||= (Ractor.current[:Psych_Visitors_Visitor] ||= Visitor.dispatch_cache)
|
||||
end
|
||||
else
|
||||
DISPATCH = dispatch_cache
|
||||
|
|
|
@ -509,9 +509,9 @@ module Psych
|
|||
def emit_coder c, o
|
||||
case c.type
|
||||
when :scalar
|
||||
@emitter.scalar c.scalar, nil, c.tag, c.tag.nil?, false, Nodes::Scalar::ANY
|
||||
@emitter.scalar c.scalar, nil, c.tag, c.tag.nil?, false, c.style
|
||||
when :seq
|
||||
@emitter.start_sequence nil, c.tag, c.tag.nil?, Nodes::Sequence::BLOCK
|
||||
@emitter.start_sequence nil, c.tag, c.tag.nil?, c.style
|
||||
c.seq.each do |thing|
|
||||
accept thing
|
||||
end
|
||||
|
|
|
@ -541,4 +541,4 @@ yaml_parser_load_mapping_end(yaml_parser_t *parser, yaml_event_t *event,
|
|||
(void)POP(parser, *ctx);
|
||||
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -273,7 +273,7 @@
|
|||
* The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation
|
||||
* increase that precedes a block collection (cf. the INDENT token in Python).
|
||||
* The token BLOCK-END denote indentation decrease that ends a block collection
|
||||
* (cf. the DEDENT token in Python). However YAML has some syntax pecularities
|
||||
* (cf. the DEDENT token in Python). However YAML has some syntax peculiarities
|
||||
* that makes detections of these tokens more complex.
|
||||
*
|
||||
* The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators
|
||||
|
@ -3287,7 +3287,7 @@ yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token,
|
|||
|
||||
/* Check if we are at the end of the scalar. */
|
||||
|
||||
/* Fix for crash unitialized value crash
|
||||
/* Fix for crash uninitialized value crash
|
||||
* Credit for the bug and input is to OSS Fuzz
|
||||
* Credit for the fix to Alex Gaynor
|
||||
*/
|
||||
|
|
|
@ -1095,7 +1095,7 @@ typedef struct yaml_parser_s {
|
|||
yaml_error_type_t error;
|
||||
/** Error description. */
|
||||
const char *problem;
|
||||
/** The byte about which the problem occured. */
|
||||
/** The byte about which the problem occurred. */
|
||||
size_t problem_offset;
|
||||
/** The problematic value (@c -1 is none). */
|
||||
int problem_value;
|
||||
|
@ -1335,7 +1335,7 @@ yaml_parser_delete(yaml_parser_t *parser);
|
|||
* Set a string input.
|
||||
*
|
||||
* Note that the @a input pointer must be valid while the @a parser object
|
||||
* exists. The application is responsible for destroing @a input after
|
||||
* exists. The application is responsible for destroying @a input after
|
||||
* destroying the @a parser.
|
||||
*
|
||||
* @param[in,out] parser A parser object.
|
||||
|
@ -1734,7 +1734,7 @@ typedef struct yaml_emitter_s {
|
|||
size_t length;
|
||||
/** Does the scalar contain line breaks? */
|
||||
int multiline;
|
||||
/** Can the scalar be expessed in the flow plain style? */
|
||||
/** Can the scalar be expressed in the flow plain style? */
|
||||
int flow_plain_allowed;
|
||||
/** Can the scalar be expressed in the block plain style? */
|
||||
int block_plain_allowed;
|
||||
|
@ -1950,7 +1950,7 @@ yaml_emitter_close(yaml_emitter_t *emitter);
|
|||
/**
|
||||
* Emit a YAML document.
|
||||
*
|
||||
* The documen object may be generated using the yaml_parser_load() function
|
||||
* The document object may be generated using the yaml_parser_load() function
|
||||
* or the yaml_document_initialize() function. The emitter takes the
|
||||
* responsibility for the document object and destroys its content after
|
||||
* it is emitted. The document object is destroyed even if the function fails.
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
#include RUBY_EXTCONF_H
|
||||
#endif
|
||||
|
||||
#if HAVE_CONFIG_H
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
# frozen_string_literal: true
|
||||
require 'minitest/autorun'
|
||||
require 'test/unit'
|
||||
require 'stringio'
|
||||
require 'tempfile'
|
||||
require 'date'
|
||||
|
@ -7,13 +7,7 @@ require 'date'
|
|||
require 'psych'
|
||||
|
||||
module Psych
|
||||
superclass = if defined?(Minitest::Test)
|
||||
Minitest::Test
|
||||
else
|
||||
MiniTest::Unit::TestCase
|
||||
end
|
||||
|
||||
class TestCase < superclass
|
||||
class TestCase < Test::Unit::TestCase
|
||||
def self.suppress_warning
|
||||
verbose, $VERBOSE = $VERBOSE, nil
|
||||
yield
|
||||
|
@ -47,24 +41,30 @@ module Psych
|
|||
# Convert between Psych and the object to verify correct parsing and
|
||||
# emitting
|
||||
#
|
||||
def assert_to_yaml( obj, yaml )
|
||||
assert_equal( obj, Psych::load( yaml ) )
|
||||
def assert_to_yaml( obj, yaml, loader = :load )
|
||||
assert_equal( obj, Psych.send(loader, yaml) )
|
||||
assert_equal( obj, Psych::parse( yaml ).transform )
|
||||
assert_equal( obj, Psych::load( obj.to_yaml ) )
|
||||
assert_equal( obj, Psych.send(loader, obj.to_yaml) )
|
||||
assert_equal( obj, Psych::parse( obj.to_yaml ).transform )
|
||||
assert_equal( obj, Psych::load(
|
||||
assert_equal( obj, Psych.send(loader,
|
||||
obj.to_yaml(
|
||||
:UseVersion => true, :UseHeader => true, :SortKeys => true
|
||||
)
|
||||
))
|
||||
rescue Psych::DisallowedClass, Psych::BadAlias
|
||||
assert_to_yaml obj, yaml, :unsafe_load
|
||||
end
|
||||
|
||||
#
|
||||
# Test parser only
|
||||
#
|
||||
def assert_parse_only( obj, yaml )
|
||||
assert_equal( obj, Psych::load( yaml ) )
|
||||
assert_equal( obj, Psych::parse( yaml ).transform )
|
||||
begin
|
||||
assert_equal obj, Psych::load( yaml )
|
||||
rescue Psych::DisallowedClass, Psych::BadAlias
|
||||
assert_equal obj, Psych::unsafe_load( yaml )
|
||||
end
|
||||
assert_equal obj, Psych::parse( yaml ).transform
|
||||
end
|
||||
|
||||
def assert_cycle( obj )
|
||||
|
@ -75,9 +75,15 @@ module Psych
|
|||
assert_nil Psych::load(Psych.dump(obj))
|
||||
assert_nil Psych::load(obj.to_yaml)
|
||||
else
|
||||
assert_equal(obj, Psych.load(v.tree.yaml))
|
||||
assert_equal(obj, Psych::load(Psych.dump(obj)))
|
||||
assert_equal(obj, Psych::load(obj.to_yaml))
|
||||
begin
|
||||
assert_equal(obj, Psych.load(v.tree.yaml))
|
||||
assert_equal(obj, Psych::load(Psych.dump(obj)))
|
||||
assert_equal(obj, Psych::load(obj.to_yaml))
|
||||
rescue Psych::DisallowedClass, Psych::BadAlias
|
||||
assert_equal(obj, Psych.unsafe_load(v.tree.yaml))
|
||||
assert_equal(obj, Psych::unsafe_load(Psych.dump(obj)))
|
||||
assert_equal(obj, Psych::unsafe_load(obj.to_yaml))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
|
|
@ -19,7 +19,7 @@ module Psych
|
|||
- *id001
|
||||
- *id001
|
||||
EOYAML
|
||||
result = Psych.load yaml
|
||||
result = Psych.unsafe_load yaml
|
||||
result.each {|el| assert_same(result[0], el) }
|
||||
end
|
||||
|
||||
|
@ -33,7 +33,7 @@ EOYAML
|
|||
- *id001
|
||||
EOYAML
|
||||
|
||||
result = Psych.load yaml
|
||||
result = Psych.unsafe_load yaml
|
||||
result.each do |el|
|
||||
assert_same(result[0], el)
|
||||
assert_equal('test1', el.var1)
|
||||
|
@ -50,7 +50,7 @@ EOYAML
|
|||
- *id001
|
||||
- *id001
|
||||
EOYAML
|
||||
result = Psych.load yaml
|
||||
result = Psych.unsafe_load yaml
|
||||
result.each do |el|
|
||||
assert_same(result[0], el)
|
||||
assert_equal('test', el.var1)
|
||||
|
@ -62,7 +62,7 @@ EOYAML
|
|||
original = [o,o,o]
|
||||
|
||||
yaml = Psych.dump original
|
||||
result = Psych.load yaml
|
||||
result = Psych.unsafe_load yaml
|
||||
result.each {|el| assert_same(result[0], el) }
|
||||
end
|
||||
|
||||
|
@ -73,7 +73,7 @@ EOYAML
|
|||
original = [o,o,o]
|
||||
|
||||
yaml = Psych.dump original
|
||||
result = Psych.load yaml
|
||||
result = Psych.unsafe_load yaml
|
||||
result.each do |el|
|
||||
assert_same(result[0], el)
|
||||
assert_equal('test1', el.var1)
|
||||
|
@ -87,7 +87,7 @@ EOYAML
|
|||
original = [o,o,o]
|
||||
|
||||
yaml = Psych.dump original
|
||||
result = Psych.load yaml
|
||||
result = Psych.unsafe_load yaml
|
||||
result.each do |el|
|
||||
assert_same(result[0], el)
|
||||
assert_equal('test', el.var1)
|
||||
|
|
|
@ -24,7 +24,7 @@ module Psych
|
|||
def test_another_subclass_with_attributes
|
||||
y = Y.new.tap {|o| o.val = 1}
|
||||
y << "foo" << "bar"
|
||||
y = Psych.load Psych.dump y
|
||||
y = Psych.unsafe_load Psych.dump y
|
||||
|
||||
assert_equal %w{foo bar}, y
|
||||
assert_equal Y, y.class
|
||||
|
@ -42,13 +42,13 @@ module Psych
|
|||
end
|
||||
|
||||
def test_subclass_with_attributes
|
||||
y = Psych.load Psych.dump Y.new.tap {|o| o.val = 1}
|
||||
y = Psych.unsafe_load Psych.dump Y.new.tap {|o| o.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"
|
||||
x = Psych.unsafe_load "--- !seq:#{X.name} []\n\n"
|
||||
assert_equal X, x.class
|
||||
end
|
||||
|
||||
|
|
|
@ -7,13 +7,13 @@ module Psych
|
|||
end
|
||||
|
||||
def test_cycle_anonymous_class
|
||||
assert_raises(::TypeError) do
|
||||
assert_raise(::TypeError) do
|
||||
assert_cycle(Class.new)
|
||||
end
|
||||
end
|
||||
|
||||
def test_cycle_anonymous_module
|
||||
assert_raises(::TypeError) do
|
||||
assert_raise(::TypeError) do
|
||||
assert_cycle(Module.new)
|
||||
end
|
||||
end
|
||||
|
|
|
@ -112,9 +112,19 @@ module Psych
|
|||
end
|
||||
end
|
||||
|
||||
class CustomEncode
|
||||
def initialize(**opts)
|
||||
@opts = opts
|
||||
end
|
||||
|
||||
def encode_with(coder)
|
||||
@opts.each { |k,v| coder.public_send :"#{k}=", v }
|
||||
end
|
||||
end
|
||||
|
||||
def test_self_referential
|
||||
x = Referential.new
|
||||
copy = Psych.load Psych.dump x
|
||||
copy = Psych.unsafe_load Psych.dump x
|
||||
assert_equal copy, copy.a
|
||||
end
|
||||
|
||||
|
@ -153,23 +163,23 @@ module Psych
|
|||
end
|
||||
|
||||
def test_represent_map
|
||||
thing = Psych.load(Psych.dump(RepresentWithMap.new))
|
||||
thing = Psych.unsafe_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))
|
||||
thing = Psych.unsafe_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))
|
||||
thing = Psych.unsafe_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)))
|
||||
assert_instance_of(Represent, Psych.unsafe_load(Psych.dump(Represent.new)))
|
||||
end
|
||||
|
||||
def test_scalar_coder
|
||||
|
@ -179,7 +189,7 @@ module Psych
|
|||
|
||||
def test_load_dumped_tagging
|
||||
foo = InitApi.new
|
||||
bar = Psych.load(Psych.dump(foo))
|
||||
bar = Psych.unsafe_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
|
||||
|
@ -198,10 +208,121 @@ module Psych
|
|||
|
||||
def test_dump_init_with
|
||||
foo = InitApi.new
|
||||
bar = Psych.load(Psych.dump(foo))
|
||||
bar = Psych.unsafe_load(Psych.dump(foo))
|
||||
assert_equal foo.a, bar.a
|
||||
assert_equal foo.b, bar.b
|
||||
assert_nil bar.c
|
||||
end
|
||||
|
||||
def test_coder_style_map_default
|
||||
foo = Psych.dump a: 1, b: 2
|
||||
assert_equal foo, "---\n:a: 1\n:b: 2\n"
|
||||
end
|
||||
|
||||
def test_coder_style_map_any
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
map: {a: 1, b: 2},
|
||||
style: Psych::Nodes::Mapping::ANY,
|
||||
tag: nil
|
||||
assert_equal foo, "---\n:a: 1\n:b: 2\n"
|
||||
end
|
||||
|
||||
def test_coder_style_map_block
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
map: {a: 1, b: 2},
|
||||
style: Psych::Nodes::Mapping::BLOCK,
|
||||
tag: nil
|
||||
assert_equal foo, "---\n:a: 1\n:b: 2\n"
|
||||
end
|
||||
|
||||
def test_coder_style_map_flow
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
map: { a: 1, b: 2 },
|
||||
style: Psych::Nodes::Mapping::FLOW,
|
||||
tag: nil
|
||||
assert_equal foo, "--- {! ':a': 1, ! ':b': 2}\n"
|
||||
end
|
||||
|
||||
def test_coder_style_seq_default
|
||||
foo = Psych.dump [ 1, 2, 3 ]
|
||||
assert_equal foo, "---\n- 1\n- 2\n- 3\n"
|
||||
end
|
||||
|
||||
def test_coder_style_seq_any
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
seq: [ 1, 2, 3 ],
|
||||
style: Psych::Nodes::Sequence::ANY,
|
||||
tag: nil
|
||||
assert_equal foo, "---\n- 1\n- 2\n- 3\n"
|
||||
end
|
||||
|
||||
def test_coder_style_seq_block
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
seq: [ 1, 2, 3 ],
|
||||
style: Psych::Nodes::Sequence::BLOCK,
|
||||
tag: nil
|
||||
assert_equal foo, "---\n- 1\n- 2\n- 3\n"
|
||||
end
|
||||
|
||||
def test_coder_style_seq_flow
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
seq: [ 1, 2, 3 ],
|
||||
style: Psych::Nodes::Sequence::FLOW,
|
||||
tag: nil
|
||||
assert_equal foo, "--- [1, 2, 3]\n"
|
||||
end
|
||||
|
||||
def test_coder_style_scalar_default
|
||||
foo = Psych.dump 'some scalar'
|
||||
assert_equal foo, "--- some scalar\n"
|
||||
end
|
||||
|
||||
def test_coder_style_scalar_any
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
scalar: 'some scalar',
|
||||
style: Psych::Nodes::Scalar::ANY,
|
||||
tag: nil
|
||||
assert_equal foo, "--- some scalar\n"
|
||||
end
|
||||
|
||||
def test_coder_style_scalar_plain
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
scalar: 'some scalar',
|
||||
style: Psych::Nodes::Scalar::PLAIN,
|
||||
tag: nil
|
||||
assert_equal foo, "--- some scalar\n"
|
||||
end
|
||||
|
||||
def test_coder_style_scalar_single_quoted
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
scalar: 'some scalar',
|
||||
style: Psych::Nodes::Scalar::SINGLE_QUOTED,
|
||||
tag: nil
|
||||
assert_equal foo, "--- ! 'some scalar'\n"
|
||||
end
|
||||
|
||||
def test_coder_style_scalar_double_quoted
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
scalar: 'some scalar',
|
||||
style: Psych::Nodes::Scalar::DOUBLE_QUOTED,
|
||||
tag: nil
|
||||
assert_equal foo, %Q'--- ! "some scalar"\n'
|
||||
end
|
||||
|
||||
def test_coder_style_scalar_literal
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
scalar: 'some scalar',
|
||||
style: Psych::Nodes::Scalar::LITERAL,
|
||||
tag: nil
|
||||
assert_equal foo, "--- ! |-\n some scalar\n"
|
||||
end
|
||||
|
||||
def test_coder_style_scalar_folded
|
||||
foo = Psych.dump CustomEncode.new \
|
||||
scalar: 'some scalar',
|
||||
style: Psych::Nodes::Scalar::FOLDED,
|
||||
tag: nil
|
||||
assert_equal foo, "--- ! >-\n some scalar\n"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
@ -22,7 +22,7 @@ module Psych
|
|||
def test_timezone_offset
|
||||
times = [Time.new(2017, 4, 13, 12, 0, 0, "+09:00"),
|
||||
Time.new(2017, 4, 13, 12, 0, 0, "-05:00")]
|
||||
cycled = Psych::load(Psych.dump times)
|
||||
cycled = Psych::unsafe_load(Psych.dump times)
|
||||
assert_match(/12:00:00 \+0900/, cycled.first.to_s)
|
||||
assert_match(/12:00:00 -0500/, cycled.last.to_s)
|
||||
end
|
||||
|
@ -39,7 +39,7 @@ module Psych
|
|||
def test_datetime_timezone_offset
|
||||
times = [DateTime.new(2017, 4, 13, 12, 0, 0, "+09:00"),
|
||||
DateTime.new(2017, 4, 13, 12, 0, 0, "-05:00")]
|
||||
cycled = Psych::load(Psych.dump times)
|
||||
cycled = Psych::unsafe_load(Psych.dump times)
|
||||
assert_match(/12:00:00\+09:00/, cycled.first.to_s)
|
||||
assert_match(/12:00:00-05:00/, cycled.last.to_s)
|
||||
end
|
||||
|
|
|
@ -41,7 +41,7 @@ module Psych
|
|||
def test_recursive_quick_emit_encode_with
|
||||
qeew = QuickEmitterEncodeWith.new
|
||||
hash = { :qe => qeew }
|
||||
hash2 = Psych.load Psych.dump hash
|
||||
hash2 = Psych.unsafe_load Psych.dump hash
|
||||
qe = hash2[:qe]
|
||||
|
||||
assert_equal qeew.name, qe.name
|
||||
|
@ -72,7 +72,7 @@ module Psych
|
|||
# receive the yaml_initialize call.
|
||||
def test_yaml_initialize_and_init_with
|
||||
hash = { :yi => YamlInitAndInitWith.new }
|
||||
hash2 = Psych.load Psych.dump hash
|
||||
hash2 = Psych.unsafe_load Psych.dump hash
|
||||
yi = hash2[:yi]
|
||||
|
||||
assert_equal 'TGIF!', yi.name
|
||||
|
|
|
@ -30,7 +30,7 @@ module Psych
|
|||
end
|
||||
|
||||
def test_emit_bad_tag
|
||||
assert_raises(RuntimeError) do
|
||||
assert_raise(RuntimeError) do
|
||||
@doc.tag_directives = [['!']]
|
||||
@stream.yaml
|
||||
end
|
||||
|
|
|
@ -40,7 +40,7 @@ module Psych
|
|||
end
|
||||
|
||||
def test_start_stream_arg_error
|
||||
assert_raises(TypeError) do
|
||||
assert_raise(TypeError) do
|
||||
@emitter.start_stream 'asdfasdf'
|
||||
end
|
||||
end
|
||||
|
@ -56,7 +56,7 @@ module Psych
|
|||
[[], [nil,nil], false],
|
||||
[[1,1], [[nil, "tag:TALOS"]], 0],
|
||||
].each do |args|
|
||||
assert_raises(TypeError) do
|
||||
assert_raise(TypeError) do
|
||||
@emitter.start_document(*args)
|
||||
end
|
||||
end
|
||||
|
@ -73,7 +73,7 @@ module Psych
|
|||
['foo', nil, nil, false, true, :foo],
|
||||
[nil, nil, nil, false, true, 1],
|
||||
].each do |args|
|
||||
assert_raises(TypeError) do
|
||||
assert_raise(TypeError) do
|
||||
@emitter.scalar(*args)
|
||||
end
|
||||
end
|
||||
|
@ -83,11 +83,11 @@ module Psych
|
|||
@emitter.start_stream Psych::Nodes::Stream::UTF8
|
||||
@emitter.start_document [], [], false
|
||||
|
||||
assert_raises(TypeError) do
|
||||
assert_raise(TypeError) do
|
||||
@emitter.start_sequence(nil, Object.new, true, 1)
|
||||
end
|
||||
|
||||
assert_raises(TypeError) do
|
||||
assert_raise(TypeError) do
|
||||
@emitter.start_sequence(nil, nil, true, :foo)
|
||||
end
|
||||
end
|
||||
|
|
|
@ -63,7 +63,7 @@ module Psych
|
|||
# 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
|
||||
assert_raise Psych::SyntaxError do
|
||||
Psych.load(f)
|
||||
end
|
||||
end
|
||||
|
@ -121,7 +121,7 @@ module Psych
|
|||
def test_emit_alias
|
||||
@emitter.start_stream Psych::Parser::UTF8
|
||||
@emitter.start_document [], [], true
|
||||
e = assert_raises(RuntimeError) do
|
||||
e = assert_raise(RuntimeError) do
|
||||
@emitter.alias 'ドラえもん'.encode('EUC-JP')
|
||||
end
|
||||
assert_match(/alias value/, e.message)
|
||||
|
|
|
@ -33,42 +33,42 @@ module Psych
|
|||
|
||||
def test_backtrace
|
||||
err = make_ex
|
||||
new_err = Psych.load(Psych.dump(err))
|
||||
new_err = Psych.unsafe_load(Psych.dump(err))
|
||||
assert_equal err.backtrace, new_err.backtrace
|
||||
end
|
||||
|
||||
def test_naming_exception
|
||||
err = String.xxx rescue $!
|
||||
new_err = Psych.load(Psych.dump(err))
|
||||
new_err = Psych.unsafe_load(Psych.dump(err))
|
||||
assert_equal err.message, new_err.message
|
||||
end
|
||||
|
||||
def test_load_takes_file
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.load '--- `'
|
||||
end
|
||||
assert_nil ex.file
|
||||
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.load '--- `', filename: 'meow'
|
||||
end
|
||||
assert_equal 'meow', ex.file
|
||||
|
||||
# deprecated interface
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
Psych.load '--- `', 'deprecated'
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.unsafe_load '--- `', 'deprecated'
|
||||
end
|
||||
assert_equal 'deprecated', ex.file
|
||||
end
|
||||
|
||||
def test_psych_parse_stream_takes_file
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.parse_stream '--- `'
|
||||
end
|
||||
assert_nil ex.file
|
||||
assert_match '(<unknown>)', ex.message
|
||||
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.parse_stream '--- `', filename: 'omg!'
|
||||
end
|
||||
assert_equal 'omg!', ex.file
|
||||
|
@ -76,19 +76,19 @@ module Psych
|
|||
end
|
||||
|
||||
def test_load_stream_takes_file
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.load_stream '--- `'
|
||||
end
|
||||
assert_nil ex.file
|
||||
assert_match '(<unknown>)', ex.message
|
||||
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.load_stream '--- `', filename: 'omg!'
|
||||
end
|
||||
assert_equal 'omg!', ex.file
|
||||
|
||||
# deprecated interface
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.load_stream '--- `', 'deprecated'
|
||||
end
|
||||
assert_equal 'deprecated', ex.file
|
||||
|
@ -99,7 +99,7 @@ module Psych
|
|||
t.binmode
|
||||
t.write '--- `'
|
||||
t.close
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.parse_file t.path
|
||||
end
|
||||
assert_equal t.path, ex.file
|
||||
|
@ -111,7 +111,7 @@ module Psych
|
|||
t.binmode
|
||||
t.write '--- `'
|
||||
t.close
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.load_file t.path
|
||||
end
|
||||
assert_equal t.path, ex.file
|
||||
|
@ -123,7 +123,7 @@ module Psych
|
|||
t.binmode
|
||||
t.write '--- `'
|
||||
t.close
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.safe_load_file t.path
|
||||
end
|
||||
assert_equal t.path, ex.file
|
||||
|
@ -131,26 +131,26 @@ module Psych
|
|||
end
|
||||
|
||||
def test_psych_parse_takes_file
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.parse '--- `'
|
||||
end
|
||||
assert_match '(<unknown>)', ex.message
|
||||
assert_nil ex.file
|
||||
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.parse '--- `', filename: 'omg!'
|
||||
end
|
||||
assert_match 'omg!', ex.message
|
||||
|
||||
# deprecated interface
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
Psych.parse '--- `', 'deprecated'
|
||||
end
|
||||
assert_match 'deprecated', ex.message
|
||||
end
|
||||
|
||||
def test_attributes
|
||||
e = assert_raises(Psych::SyntaxError) {
|
||||
e = assert_raise(Psych::SyntaxError) {
|
||||
Psych.load '--- `foo'
|
||||
}
|
||||
|
||||
|
@ -165,7 +165,7 @@ module Psych
|
|||
end
|
||||
|
||||
def test_convert
|
||||
w = Psych.load(Psych.dump(@wups))
|
||||
w = Psych.unsafe_load(Psych.dump(@wups))
|
||||
assert_equal @wups.message, w.message
|
||||
assert_equal @wups.backtrace, w.backtrace
|
||||
assert_equal 1, w.foo
|
||||
|
|
|
@ -39,7 +39,7 @@ module Psych
|
|||
def test_hash_with_ivar
|
||||
t1 = HashWithIvar.new
|
||||
t1[:foo] = :bar
|
||||
t2 = Psych.load(Psych.dump(t1))
|
||||
t2 = Psych.unsafe_load(Psych.dump(t1))
|
||||
assert_equal t1, t2
|
||||
assert_cycle t1
|
||||
end
|
||||
|
@ -54,14 +54,14 @@ module Psych
|
|||
def test_custom_initialized
|
||||
a = [1,2,3,4,5]
|
||||
t1 = HashWithCustomInit.new(a)
|
||||
t2 = Psych.load(Psych.dump(t1))
|
||||
t2 = Psych.unsafe_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))
|
||||
t2 = Psych.unsafe_load(Psych.dump(t1))
|
||||
assert_equal t1, t2
|
||||
assert_cycle t1
|
||||
end
|
||||
|
@ -70,25 +70,25 @@ module Psych
|
|||
x = X.new
|
||||
x[:a] = 'b'
|
||||
x.instance_variable_set :@foo, 'bar'
|
||||
dup = Psych.load Psych.dump x
|
||||
dup = Psych.unsafe_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"
|
||||
hash = Psych.unsafe_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
|
||||
x = Psych.unsafe_load Psych.dump X.new
|
||||
assert_equal X, x.class
|
||||
end
|
||||
|
||||
def test_map
|
||||
x = Psych.load "--- !map:#{X} { }\n"
|
||||
x = Psych.unsafe_load "--- !map:#{X} { }\n"
|
||||
assert_equal X, x.class
|
||||
end
|
||||
|
||||
|
@ -102,7 +102,7 @@ module Psych
|
|||
end
|
||||
|
||||
def test_ref_append
|
||||
hash = Psych.load(<<-eoyml)
|
||||
hash = Psych.unsafe_load(<<-eoyml)
|
||||
---
|
||||
foo: &foo
|
||||
hello: world
|
||||
|
@ -114,7 +114,7 @@ eoyml
|
|||
|
||||
def test_key_deduplication
|
||||
unless String.method_defined?(:-@) && (-("a" * 20)).equal?((-("a" * 20)))
|
||||
skip "This Ruby implementation doesn't support string deduplication"
|
||||
pend "This Ruby implementation doesn't support string deduplication"
|
||||
end
|
||||
|
||||
hashes = Psych.load(<<-eoyml)
|
||||
|
|
|
@ -6,7 +6,7 @@ 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))
|
||||
loaded = Psych.unsafe_load(Psych.dump(sd))
|
||||
|
||||
assert_instance_of(SimpleDelegator, loaded)
|
||||
assert_equal(sd, loaded)
|
||||
|
@ -46,7 +46,15 @@ module Psych
|
|||
|
||||
def test_init_with_takes_priority_over_marshal_methods
|
||||
obj = PsychCustomMarshalable.new(1)
|
||||
loaded = Psych.load(Psych.dump(obj))
|
||||
loaded = Psych.unsafe_load(Psych.dump(obj))
|
||||
|
||||
assert(PsychCustomMarshalable === loaded)
|
||||
assert_equal(2, loaded.foo)
|
||||
end
|
||||
|
||||
def test_init_symbolize_names
|
||||
obj = PsychCustomMarshalable.new(1)
|
||||
loaded = Psych.unsafe_load(Psych.dump(obj), symbolize_names: true)
|
||||
|
||||
assert(PsychCustomMarshalable === loaded)
|
||||
assert_equal(2, loaded.foo)
|
||||
|
|
|
@ -34,7 +34,7 @@ map:
|
|||
end
|
||||
|
||||
def test_explicit_string
|
||||
doc = Psych.load <<-eoyml
|
||||
doc = Psych.unsafe_load <<-eoyml
|
||||
a: &me { hello: world }
|
||||
b: { !!str '<<': *me }
|
||||
eoyml
|
||||
|
@ -55,7 +55,7 @@ product:
|
|||
!ruby/object:#{Product.name}
|
||||
<<: *foo
|
||||
eoyml
|
||||
hash = Psych.load s
|
||||
hash = Psych.unsafe_load s
|
||||
assert_equal({"bar" => 10}, hash["foo"])
|
||||
product = hash["product"]
|
||||
assert_equal 10, product.bar
|
||||
|
@ -67,7 +67,7 @@ defaults: &defaults
|
|||
development:
|
||||
<<: *defaults
|
||||
eoyml
|
||||
assert_equal({'<<' => nil }, Psych.load(yaml)['development'])
|
||||
assert_equal({'<<' => nil }, Psych.unsafe_load(yaml)['development'])
|
||||
end
|
||||
|
||||
def test_merge_array
|
||||
|
@ -77,7 +77,7 @@ foo: &hello
|
|||
baz:
|
||||
<<: *hello
|
||||
eoyml
|
||||
assert_equal({'<<' => [1]}, Psych.load(yaml)['baz'])
|
||||
assert_equal({'<<' => [1]}, Psych.unsafe_load(yaml)['baz'])
|
||||
end
|
||||
|
||||
def test_merge_is_not_partial
|
||||
|
@ -89,9 +89,9 @@ foo: &hello
|
|||
baz:
|
||||
<<: [*hello, *default]
|
||||
eoyml
|
||||
doc = Psych.load yaml
|
||||
doc = Psych.unsafe_load yaml
|
||||
refute doc['baz'].key? 'hello'
|
||||
assert_equal({'<<' => [[1], {"hello"=>"world"}]}, Psych.load(yaml)['baz'])
|
||||
assert_equal({'<<' => [[1], {"hello"=>"world"}]}, Psych.unsafe_load(yaml)['baz'])
|
||||
end
|
||||
|
||||
def test_merge_seq_nil
|
||||
|
@ -100,7 +100,7 @@ foo: &hello
|
|||
baz:
|
||||
<<: [*hello]
|
||||
eoyml
|
||||
assert_equal({'<<' => [nil]}, Psych.load(yaml)['baz'])
|
||||
assert_equal({'<<' => [nil]}, Psych.unsafe_load(yaml)['baz'])
|
||||
end
|
||||
|
||||
def test_bad_seq_merge
|
||||
|
@ -109,7 +109,7 @@ defaults: &defaults [1, 2, 3]
|
|||
development:
|
||||
<<: *defaults
|
||||
eoyml
|
||||
assert_equal({'<<' => [1,2,3]}, Psych.load(yaml)['development'])
|
||||
assert_equal({'<<' => [1,2,3]}, Psych.unsafe_load(yaml)['development'])
|
||||
end
|
||||
|
||||
def test_missing_merge_key
|
||||
|
@ -117,7 +117,7 @@ development:
|
|||
bar:
|
||||
<< : *foo
|
||||
eoyml
|
||||
exp = assert_raises(Psych::BadAlias) { Psych.load yaml }
|
||||
exp = assert_raise(Psych::BadAlias) { Psych.load yaml }
|
||||
assert_match 'foo', exp.message
|
||||
end
|
||||
|
||||
|
@ -134,7 +134,7 @@ bar:
|
|||
hash = {
|
||||
"foo" => { "hello" => "world"},
|
||||
"bar" => { "hello" => "world", "baz" => "boo" } }
|
||||
assert_equal hash, Psych.load(yaml)
|
||||
assert_equal hash, Psych.unsafe_load(yaml)
|
||||
end
|
||||
|
||||
def test_multiple_maps
|
||||
|
@ -159,7 +159,7 @@ bar:
|
|||
'label' => 'center/big'
|
||||
}
|
||||
|
||||
assert_equal hash, Psych.load(yaml)[4]
|
||||
assert_equal hash, Psych.unsafe_load(yaml)[4]
|
||||
end
|
||||
|
||||
def test_override
|
||||
|
@ -185,7 +185,7 @@ bar:
|
|||
'label' => 'center/big'
|
||||
}
|
||||
|
||||
assert_equal hash, Psych.load(yaml)[4]
|
||||
assert_equal hash, Psych.unsafe_load(yaml)[4]
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
@ -28,7 +28,7 @@ module Psych
|
|||
|
||||
def test_tag_round_trip
|
||||
tag = Tagged.new
|
||||
tag2 = Psych.load(Psych.dump(tag))
|
||||
tag2 = Psych.unsafe_load(Psych.dump(tag))
|
||||
assert_equal tag.baz, tag2.baz
|
||||
assert_instance_of(Tagged, tag2)
|
||||
end
|
||||
|
@ -36,7 +36,7 @@ module Psych
|
|||
def test_cyclic_references
|
||||
foo = Foo.new(nil)
|
||||
foo.parent = foo
|
||||
loaded = Psych.load Psych.dump foo
|
||||
loaded = Psych.unsafe_load Psych.dump foo
|
||||
|
||||
assert_instance_of(Foo, loaded)
|
||||
assert_equal loaded, loaded.parent
|
||||
|
|
|
@ -34,12 +34,16 @@ module Psych
|
|||
def assert_reference_trip obj
|
||||
yml = Psych.dump([obj, obj])
|
||||
assert_match(/\*-?\d+/, yml)
|
||||
data = Psych.load yml
|
||||
begin
|
||||
data = Psych.load yml
|
||||
rescue Psych::DisallowedClass
|
||||
data = Psych.unsafe_load yml
|
||||
end
|
||||
assert_equal data.first.object_id, data.last.object_id
|
||||
end
|
||||
|
||||
def test_float_references
|
||||
data = Psych.load <<-eoyml
|
||||
data = Psych.unsafe_load <<-eoyml
|
||||
---\s
|
||||
- &name 1.2
|
||||
- *name
|
||||
|
@ -49,7 +53,7 @@ module Psych
|
|||
end
|
||||
|
||||
def test_binary_references
|
||||
data = Psych.load <<-eoyml
|
||||
data = Psych.unsafe_load <<-eoyml
|
||||
---
|
||||
- &name !binary |-
|
||||
aGVsbG8gd29ybGQh
|
||||
|
@ -60,7 +64,7 @@ module Psych
|
|||
end
|
||||
|
||||
def test_regexp_references
|
||||
data = Psych.load <<-eoyml
|
||||
data = Psych.unsafe_load <<-eoyml
|
||||
---\s
|
||||
- &name !ruby/regexp /pattern/i
|
||||
- *name
|
||||
|
|
|
@ -4,7 +4,7 @@ require_relative 'helper'
|
|||
module Psych
|
||||
class TestOmap < TestCase
|
||||
def test_parse_as_map
|
||||
o = Psych.load "--- !!omap\na: 1\nb: 2"
|
||||
o = Psych.unsafe_load "--- !!omap\na: 1\nb: 2"
|
||||
assert_kind_of Psych::Omap, o
|
||||
assert_equal 1, o['a']
|
||||
assert_equal 2, o['b']
|
||||
|
@ -14,7 +14,7 @@ module Psych
|
|||
map = Psych::Omap.new
|
||||
map['foo'] = 'bar'
|
||||
map['self'] = map
|
||||
assert_equal(map, Psych.load(Psych.dump(map)))
|
||||
assert_equal(map, Psych.unsafe_load(Psych.dump(map)))
|
||||
end
|
||||
|
||||
def test_keys
|
||||
|
|
|
@ -63,7 +63,7 @@ module Psych
|
|||
|
||||
parser = Psych::Parser.new klass.new
|
||||
2.times {
|
||||
assert_raises(RuntimeError, method.to_s) do
|
||||
assert_raise(RuntimeError, method.to_s) do
|
||||
parser.parse yaml
|
||||
end
|
||||
}
|
||||
|
@ -77,7 +77,7 @@ module Psych
|
|||
end
|
||||
|
||||
def test_filename
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
ex = assert_raise(Psych::SyntaxError) do
|
||||
@parser.parse '--- `', 'omg!'
|
||||
end
|
||||
assert_match 'omg!', ex.message
|
||||
|
@ -180,7 +180,7 @@ module Psych
|
|||
def o.external_encoding; nil end
|
||||
def o.read len; self end
|
||||
|
||||
assert_raises(TypeError) do
|
||||
assert_raise(TypeError) do
|
||||
@parser.parse o
|
||||
end
|
||||
end
|
||||
|
@ -193,23 +193,23 @@ module Psych
|
|||
end
|
||||
|
||||
def test_syntax_error
|
||||
assert_raises(Psych::SyntaxError) do
|
||||
assert_raise(Psych::SyntaxError) do
|
||||
@parser.parse("---\n\"foo\"\n\"bar\"\n")
|
||||
end
|
||||
end
|
||||
|
||||
def test_syntax_error_twice
|
||||
assert_raises(Psych::SyntaxError) do
|
||||
assert_raise(Psych::SyntaxError) do
|
||||
@parser.parse("---\n\"foo\"\n\"bar\"\n")
|
||||
end
|
||||
|
||||
assert_raises(Psych::SyntaxError) do
|
||||
assert_raise(Psych::SyntaxError) do
|
||||
@parser.parse("---\n\"foo\"\n\"bar\"\n")
|
||||
end
|
||||
end
|
||||
|
||||
def test_syntax_error_has_path_for_string
|
||||
e = assert_raises(Psych::SyntaxError) do
|
||||
e = assert_raise(Psych::SyntaxError) do
|
||||
@parser.parse("---\n\"foo\"\n\"bar\"\n")
|
||||
end
|
||||
assert_match '(<unknown>):', e.message
|
||||
|
@ -219,7 +219,7 @@ module Psych
|
|||
io = StringIO.new "---\n\"foo\"\n\"bar\"\n"
|
||||
def io.path; "hello!"; end
|
||||
|
||||
e = assert_raises(Psych::SyntaxError) do
|
||||
e = assert_raise(Psych::SyntaxError) do
|
||||
@parser.parse(io)
|
||||
end
|
||||
assert_match "(#{io.path}):", e.message
|
||||
|
|
|
@ -16,7 +16,7 @@ class TestPsych < Psych::TestCase
|
|||
end
|
||||
|
||||
def test_line_width_invalid
|
||||
assert_raises(ArgumentError) { Psych.dump('x', { :line_width => -2 }) }
|
||||
assert_raise(ArgumentError) { Psych.dump('x', { :line_width => -2 }) }
|
||||
end
|
||||
|
||||
def test_line_width_no_limit
|
||||
|
@ -61,7 +61,7 @@ class TestPsych < Psych::TestCase
|
|||
end
|
||||
|
||||
def test_load_argument_error
|
||||
assert_raises(TypeError) do
|
||||
assert_raise(TypeError) do
|
||||
Psych.load nil
|
||||
end
|
||||
end
|
||||
|
@ -75,7 +75,7 @@ class TestPsych < Psych::TestCase
|
|||
end
|
||||
|
||||
def test_parse_raises_on_bad_input
|
||||
assert_raises(Psych::SyntaxError) { Psych.parse("--- `") }
|
||||
assert_raise(Psych::SyntaxError) { Psych.parse("--- `") }
|
||||
end
|
||||
|
||||
def test_parse_with_fallback
|
||||
|
@ -83,8 +83,8 @@ class TestPsych < Psych::TestCase
|
|||
end
|
||||
|
||||
def test_non_existing_class_on_deserialize
|
||||
e = assert_raises(ArgumentError) do
|
||||
Psych.load("--- !ruby/object:NonExistent\nfoo: 1")
|
||||
e = assert_raise(ArgumentError) do
|
||||
Psych.unsafe_load("--- !ruby/object:NonExistent\nfoo: 1")
|
||||
end
|
||||
assert_equal 'undefined class/module NonExistent', e.message
|
||||
end
|
||||
|
@ -143,7 +143,7 @@ class TestPsych < Psych::TestCase
|
|||
end
|
||||
|
||||
def test_load_stream_raises_on_bad_input
|
||||
assert_raises(Psych::SyntaxError) { Psych.load_stream("--- `") }
|
||||
assert_raise(Psych::SyntaxError) { Psych.load_stream("--- `") }
|
||||
end
|
||||
|
||||
def test_parse_stream
|
||||
|
@ -175,7 +175,7 @@ class TestPsych < Psych::TestCase
|
|||
end
|
||||
|
||||
def test_parse_stream_raises_on_bad_input
|
||||
assert_raises(Psych::SyntaxError) { Psych.parse_stream("--- `") }
|
||||
assert_raise(Psych::SyntaxError) { Psych.parse_stream("--- `") }
|
||||
end
|
||||
|
||||
def test_add_builtin_type
|
||||
|
@ -214,7 +214,7 @@ class TestPsych < Psych::TestCase
|
|||
|
||||
def test_load_freeze_deduplication
|
||||
unless String.method_defined?(:-@) && (-("a" * 20)).equal?((-("a" * 20)))
|
||||
skip "This Ruby implementation doesn't support string deduplication"
|
||||
pend "This Ruby implementation doesn't support string deduplication"
|
||||
end
|
||||
|
||||
data = Psych.load("--- ['a']", freeze: true)
|
||||
|
@ -222,28 +222,28 @@ class TestPsych < Psych::TestCase
|
|||
end
|
||||
|
||||
def test_load_default_fallback
|
||||
assert_equal false, Psych.load("")
|
||||
assert_equal false, Psych.unsafe_load("")
|
||||
end
|
||||
|
||||
def test_load_with_fallback
|
||||
assert_equal 42, Psych.load("", "file", fallback: 42)
|
||||
assert_equal 42, Psych.load("", filename: "file", fallback: 42)
|
||||
end
|
||||
|
||||
def test_load_with_fallback_nil_or_false
|
||||
assert_nil Psych.load("", "file", fallback: nil)
|
||||
assert_equal false, Psych.load("", "file", fallback: false)
|
||||
assert_nil Psych.load("", filename: "file", fallback: nil)
|
||||
assert_equal false, Psych.load("", filename: "file", fallback: false)
|
||||
end
|
||||
|
||||
def test_load_with_fallback_hash
|
||||
assert_equal Hash.new, Psych.load("", "file", fallback: Hash.new)
|
||||
assert_equal Hash.new, Psych.load("", filename: "file", fallback: Hash.new)
|
||||
end
|
||||
|
||||
def test_load_with_fallback_for_nil
|
||||
assert_nil Psych.load("--- null", "file", fallback: 42)
|
||||
assert_nil Psych.unsafe_load("--- null", "file", fallback: 42)
|
||||
end
|
||||
|
||||
def test_load_with_fallback_for_false
|
||||
assert_equal false, Psych.load("--- false", "file", fallback: 42)
|
||||
assert_equal false, Psych.unsafe_load("--- false", "file", fallback: 42)
|
||||
end
|
||||
|
||||
def test_load_file
|
||||
|
@ -278,7 +278,7 @@ class TestPsych < Psych::TestCase
|
|||
|
||||
def test_load_file_default_fallback
|
||||
Tempfile.create(['empty', 'yml']) {|t|
|
||||
assert_equal false, Psych.load_file(t.path)
|
||||
assert_equal false, Psych.unsafe_load_file(t.path)
|
||||
}
|
||||
end
|
||||
|
||||
|
@ -325,7 +325,7 @@ class TestPsych < Psych::TestCase
|
|||
t.write("--- !ruby/range\nbegin: 0\nend: 42\nexcl: false\n")
|
||||
t.close
|
||||
assert_equal 0..42, Psych.safe_load_file(t.path, permitted_classes: [Range])
|
||||
assert_raises(Psych::DisallowedClass) {
|
||||
assert_raise(Psych::DisallowedClass) {
|
||||
Psych.safe_load_file(t.path)
|
||||
}
|
||||
}
|
||||
|
@ -347,9 +347,9 @@ class TestPsych < Psych::TestCase
|
|||
end
|
||||
|
||||
def test_degenerate_strings
|
||||
assert_equal false, Psych.load(' ')
|
||||
assert_equal false, Psych.unsafe_load(' ')
|
||||
assert_equal false, Psych.parse(' ')
|
||||
assert_equal false, Psych.load('')
|
||||
assert_equal false, Psych.unsafe_load('')
|
||||
assert_equal false, Psych.parse('')
|
||||
end
|
||||
|
||||
|
@ -371,17 +371,18 @@ class TestPsych < Psych::TestCase
|
|||
yaml = <<-eoyml
|
||||
foo:
|
||||
bar: baz
|
||||
1: 2
|
||||
hoge:
|
||||
- fuga: piyo
|
||||
eoyml
|
||||
|
||||
result = Psych.load(yaml)
|
||||
assert_equal result, { "foo" => { "bar" => "baz"}, "hoge" => [{ "fuga" => "piyo" }] }
|
||||
assert_equal result, { "foo" => { "bar" => "baz", 1 => 2 }, "hoge" => [{ "fuga" => "piyo" }] }
|
||||
|
||||
result = Psych.load(yaml, symbolize_names: true)
|
||||
assert_equal result, { foo: { bar: "baz" }, hoge: [{ fuga: "piyo" }] }
|
||||
assert_equal result, { foo: { bar: "baz", 1 => 2 }, hoge: [{ fuga: "piyo" }] }
|
||||
|
||||
result = Psych.safe_load(yaml, symbolize_names: true)
|
||||
assert_equal result, { foo: { bar: "baz" }, hoge: [{ fuga: "piyo" }] }
|
||||
assert_equal result, { foo: { bar: "baz", 1 => 2 }, hoge: [{ fuga: "piyo" }] }
|
||||
end
|
||||
end
|
||||
|
|
|
@ -6,7 +6,7 @@ class TestPsychRactor < Test::Unit::TestCase
|
|||
assert_ractor(<<~RUBY, require_relative: 'helper')
|
||||
obj = {foo: [42]}
|
||||
obj2 = Ractor.new(obj) do |obj|
|
||||
Psych.load(Psych.dump(obj))
|
||||
Psych.unsafe_load(Psych.dump(obj))
|
||||
end.take
|
||||
assert_equal obj, obj2
|
||||
RUBY
|
||||
|
@ -47,4 +47,4 @@ class TestPsychRactor < Test::Unit::TestCase
|
|||
assert_equal true, r
|
||||
RUBY
|
||||
end
|
||||
end if defined?(Test::Unit::TestCase)
|
||||
end if defined?(Ractor)
|
||||
|
|
|
@ -22,7 +22,7 @@ module Psych
|
|||
def test_no_recursion
|
||||
x = []
|
||||
x << x
|
||||
assert_raises(Psych::BadAlias) do
|
||||
assert_raise(Psych::BadAlias) do
|
||||
Psych.safe_load Psych.dump(x)
|
||||
end
|
||||
end
|
||||
|
@ -37,7 +37,7 @@ module Psych
|
|||
|
||||
def test_permitted_symbol
|
||||
yml = Psych.dump :foo
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
Psych.safe_load yml
|
||||
end
|
||||
assert_equal(
|
||||
|
@ -54,15 +54,15 @@ module Psych
|
|||
end
|
||||
|
||||
def test_symbol
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
assert_safe_cycle :foo
|
||||
end
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
Psych.safe_load '--- !ruby/symbol foo', permitted_classes: []
|
||||
end
|
||||
|
||||
# deprecated interface
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
Psych.safe_load '--- !ruby/symbol foo', []
|
||||
end
|
||||
|
||||
|
@ -75,16 +75,16 @@ module Psych
|
|||
end
|
||||
|
||||
def test_foo
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
Psych.safe_load '--- !ruby/object:Foo {}', permitted_classes: [Foo]
|
||||
end
|
||||
|
||||
# deprecated interface
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
Psych.safe_load '--- !ruby/object:Foo {}', [Foo]
|
||||
end
|
||||
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
assert_safe_cycle Foo.new
|
||||
end
|
||||
assert_kind_of(Foo, Psych.safe_load(Psych.dump(Foo.new), permitted_classes: [Foo]))
|
||||
|
@ -96,7 +96,7 @@ module Psych
|
|||
X = Struct.new(:x)
|
||||
def test_struct_depends_on_sym
|
||||
assert_safe_cycle(X.new, permitted_classes: [X, Symbol])
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
cycle X.new, permitted_classes: [X]
|
||||
end
|
||||
end
|
||||
|
@ -107,14 +107,14 @@ module Psych
|
|||
foo: bar
|
||||
eoyml
|
||||
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
Psych.safe_load(<<-eoyml, permitted_classes: [Struct])
|
||||
--- !ruby/struct
|
||||
foo: bar
|
||||
eoyml
|
||||
end
|
||||
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
Psych.safe_load(<<-eoyml, permitted_classes: [Symbol])
|
||||
--- !ruby/struct
|
||||
foo: bar
|
||||
|
@ -128,14 +128,14 @@ module Psych
|
|||
foo: bar
|
||||
eoyml
|
||||
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
Psych.safe_load(<<-eoyml, [Struct])
|
||||
--- !ruby/struct
|
||||
foo: bar
|
||||
eoyml
|
||||
end
|
||||
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_raise(Psych::DisallowedClass) do
|
||||
Psych.safe_load(<<-eoyml, [Symbol])
|
||||
--- !ruby/struct
|
||||
foo: bar
|
||||
|
@ -152,7 +152,7 @@ module Psych
|
|||
end
|
||||
|
||||
def test_safe_load_raises_on_bad_input
|
||||
assert_raises(Psych::SyntaxError) { Psych.safe_load("--- `") }
|
||||
assert_raise(Psych::SyntaxError) { Psych.safe_load("--- `") }
|
||||
end
|
||||
|
||||
private
|
||||
|
|
|
@ -17,7 +17,7 @@ module Psych
|
|||
|
||||
def test_some_object
|
||||
so = SomeObject.new('foo', [1,2,3])
|
||||
assert_equal so, Psych.load(Psych.dump(so))
|
||||
assert_equal so, Psych.unsafe_load(Psych.dump(so))
|
||||
end
|
||||
|
||||
class StructSubclass < Struct.new(:foo)
|
||||
|
@ -33,7 +33,7 @@ module Psych
|
|||
|
||||
def test_struct_subclass
|
||||
so = StructSubclass.new('foo', [1,2,3])
|
||||
assert_equal so, Psych.load(Psych.dump(so))
|
||||
assert_equal so, Psych.unsafe_load(Psych.dump(so))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
@ -21,7 +21,7 @@ module Psych
|
|||
###
|
||||
# FIXME: Syck should also support !!set as shorthand
|
||||
def test_load_from_yaml
|
||||
loaded = Psych.load(<<-eoyml)
|
||||
loaded = Psych.unsafe_load(<<-eoyml)
|
||||
--- !set
|
||||
foo: bar
|
||||
bar: baz
|
||||
|
@ -30,11 +30,11 @@ bar: baz
|
|||
end
|
||||
|
||||
def test_loaded_class
|
||||
assert_instance_of(Psych::Set, Psych.load(Psych.dump(@set)))
|
||||
assert_instance_of(Psych::Set, Psych.unsafe_load(Psych.dump(@set)))
|
||||
end
|
||||
|
||||
def test_set_shorthand
|
||||
loaded = Psych.load(<<-eoyml)
|
||||
loaded = Psych.unsafe_load(<<-eoyml)
|
||||
--- !!set
|
||||
foo: bar
|
||||
bar: baz
|
||||
|
|
|
@ -104,7 +104,7 @@ module Psych
|
|||
end
|
||||
|
||||
def test_string_subclass_with_anchor
|
||||
y = Psych.load <<-eoyml
|
||||
y = Psych.unsafe_load <<-eoyml
|
||||
---
|
||||
body:
|
||||
string: &70121654388580 !ruby/string
|
||||
|
@ -116,7 +116,7 @@ body:
|
|||
end
|
||||
|
||||
def test_self_referential_string
|
||||
y = Psych.load <<-eoyml
|
||||
y = Psych.unsafe_load <<-eoyml
|
||||
---
|
||||
string: &70121654388580 !ruby/string
|
||||
str: ! 'foo'
|
||||
|
@ -129,32 +129,32 @@ string: &70121654388580 !ruby/string
|
|||
end
|
||||
|
||||
def test_another_subclass_with_attributes
|
||||
y = Psych.load Psych.dump Y.new("foo").tap {|o| o.val = 1}
|
||||
y = Psych.unsafe_load Psych.dump Y.new("foo").tap {|o| o.val = 1}
|
||||
assert_equal "foo", y
|
||||
assert_equal Y, y.class
|
||||
assert_equal 1, y.val
|
||||
end
|
||||
|
||||
def test_backwards_with_syck
|
||||
x = Psych.load "--- !str:#{X.name} foo\n\n"
|
||||
x = Psych.unsafe_load "--- !str:#{X.name} foo\n\n"
|
||||
assert_equal X, x.class
|
||||
assert_equal 'foo', x
|
||||
end
|
||||
|
||||
def test_empty_subclass
|
||||
assert_match "!ruby/string:#{X}", Psych.dump(X.new)
|
||||
x = Psych.load Psych.dump X.new
|
||||
x = Psych.unsafe_load Psych.dump X.new
|
||||
assert_equal X, x.class
|
||||
end
|
||||
|
||||
def test_empty_character_subclass
|
||||
assert_match "!ruby/string:#{Z}", Psych.dump(Z.new)
|
||||
x = Psych.load Psych.dump Z.new
|
||||
x = Psych.unsafe_load Psych.dump Z.new
|
||||
assert_equal Z, x.class
|
||||
end
|
||||
|
||||
def test_subclass_with_attributes
|
||||
y = Psych.load Psych.dump Y.new.tap {|o| o.val = 1}
|
||||
y = Psych.unsafe_load Psych.dump Y.new.tap {|o| o.val = 1}
|
||||
assert_equal Y, y.class
|
||||
assert_equal 1, y.val
|
||||
end
|
||||
|
|
|
@ -22,7 +22,7 @@ module Psych
|
|||
ss = StructSubclass.new(nil, 'foo')
|
||||
ss.foo = ss
|
||||
|
||||
loaded = Psych.load(Psych.dump(ss))
|
||||
loaded = Psych.unsafe_load(Psych.dump(ss))
|
||||
assert_instance_of(StructSubclass, loaded.foo)
|
||||
|
||||
assert_equal(ss, loaded)
|
||||
|
@ -30,14 +30,14 @@ module Psych
|
|||
|
||||
def test_roundtrip
|
||||
thing = PsychStructWithIvar.new('bar')
|
||||
struct = Psych.load(Psych.dump(thing))
|
||||
struct = Psych.unsafe_load(Psych.dump(thing))
|
||||
|
||||
assert_equal 'hello', struct.bar
|
||||
assert_equal 'bar', struct.foo
|
||||
end
|
||||
|
||||
def test_load
|
||||
obj = Psych.load(<<-eoyml)
|
||||
obj = Psych.unsafe_load(<<-eoyml)
|
||||
--- !ruby/struct:PsychStructWithIvar
|
||||
:foo: bar
|
||||
:@bar: hello
|
||||
|
|
|
@ -17,7 +17,7 @@ class Psych_Unit_Tests < Psych::TestCase
|
|||
end
|
||||
|
||||
def test_y_method
|
||||
assert_raises(NoMethodError) do
|
||||
assert_raise(NoMethodError) do
|
||||
OpenStruct.new.y 1
|
||||
end
|
||||
end
|
||||
|
@ -573,7 +573,7 @@ EOY
|
|||
end
|
||||
|
||||
def test_spec_root_mapping
|
||||
y = Psych::load( <<EOY
|
||||
y = Psych::unsafe_load( <<EOY
|
||||
# This stream is an example of a top-level mapping.
|
||||
invoice : 34843
|
||||
date : 2001-01-23
|
||||
|
@ -1077,7 +1077,7 @@ EOY
|
|||
|
||||
# Read Psych dumped by the ruby 1.8.3.
|
||||
assert_to_yaml( Rational(1, 2), "!ruby/object:Rational 1/2\n" )
|
||||
assert_raises( ArgumentError ) { Psych.load("!ruby/object:Rational INVALID/RATIONAL\n") }
|
||||
assert_raise( ArgumentError ) { Psych.unsafe_load("!ruby/object:Rational INVALID/RATIONAL\n") }
|
||||
end
|
||||
|
||||
def test_ruby_complex
|
||||
|
@ -1089,7 +1089,7 @@ EOY
|
|||
|
||||
# Read Psych dumped by the ruby 1.8.3.
|
||||
assert_to_yaml( Complex(3, 4), "!ruby/object:Complex 3+4i\n" )
|
||||
assert_raises( ArgumentError ) { Psych.load("!ruby/object:Complex INVALID+COMPLEXi\n") }
|
||||
assert_raise( ArgumentError ) { Psych.unsafe_load("!ruby/object:Complex INVALID+COMPLEXi\n") }
|
||||
end
|
||||
|
||||
def test_emitting_indicators
|
||||
|
@ -1209,7 +1209,7 @@ EOY
|
|||
def test_circular_references
|
||||
a = []; a[0] = a; a[1] = a
|
||||
inspect_str = "[[...], [...]]"
|
||||
assert_equal( inspect_str, Psych::load(Psych.dump(a)).inspect )
|
||||
assert_equal( inspect_str, Psych::unsafe_load(Psych.dump(a)).inspect )
|
||||
end
|
||||
|
||||
#
|
||||
|
@ -1264,11 +1264,11 @@ EOY
|
|||
end
|
||||
|
||||
def test_date_out_of_range
|
||||
Psych::load('1900-01-01T00:00:00+00:00')
|
||||
Psych::unsafe_load('1900-01-01T00:00:00+00:00')
|
||||
end
|
||||
|
||||
def test_normal_exit
|
||||
Psych.load("2000-01-01 00:00:00.#{"0"*1000} +00:00\n")
|
||||
Psych.unsafe_load("2000-01-01 00:00:00.#{"0"*1000} +00:00\n")
|
||||
# '[ruby-core:13735]'
|
||||
end
|
||||
|
||||
|
|
|
@ -13,7 +13,7 @@ module Psych
|
|||
|
||||
def test_empty_string
|
||||
s = ""
|
||||
assert_equal false, Psych.load(s)
|
||||
assert_equal false, Psych.unsafe_load(s)
|
||||
assert_equal [], Psych.load_stream(s)
|
||||
assert_equal false, Psych.parse(s)
|
||||
assert_equal [], Psych.parse_stream(s).transform
|
||||
|
@ -58,8 +58,8 @@ module Psych
|
|||
|
||||
def test_NaN
|
||||
s = ".NaN"
|
||||
assert Float::NAN, Psych.load(s).nan?
|
||||
assert [Float::NAN], Psych.load_stream(s).first.nan?
|
||||
assert Psych.load(s).nan?
|
||||
assert Psych.load_stream(s).first.nan?
|
||||
assert Psych.parse(s).transform.nan?
|
||||
assert Psych.parse_stream(s).transform.first.nan?
|
||||
assert Psych.safe_load(s).nan?
|
||||
|
|
|
@ -4,7 +4,22 @@ require 'yaml/store'
|
|||
require 'tmpdir'
|
||||
|
||||
module Psych
|
||||
Psych::Store = YAML::Store unless defined?(Psych::Store)
|
||||
class YAML::Store
|
||||
alias :old_load :load
|
||||
|
||||
def load(content)
|
||||
table = YAML.load(content, fallback: false)
|
||||
if table == false
|
||||
{}
|
||||
else
|
||||
table
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
unless defined?(Psych::Store)
|
||||
Psych::Store = YAML::Store
|
||||
end
|
||||
|
||||
class YAMLStoreTest < TestCase
|
||||
def setup
|
||||
|
@ -24,61 +39,61 @@ module Psych
|
|||
|
||||
def test_opening_new_file_in_readonly_mode_should_result_in_empty_values
|
||||
@yamlstore.transaction(true) do
|
||||
assert_nil @yamlstore[:foo]
|
||||
assert_nil @yamlstore[:bar]
|
||||
assert_nil @yamlstore["foo"]
|
||||
assert_nil @yamlstore["bar"]
|
||||
end
|
||||
end
|
||||
|
||||
def test_opening_new_file_in_readwrite_mode_should_result_in_empty_values
|
||||
@yamlstore.transaction do
|
||||
assert_nil @yamlstore[:foo]
|
||||
assert_nil @yamlstore[:bar]
|
||||
assert_nil @yamlstore["foo"]
|
||||
assert_nil @yamlstore["bar"]
|
||||
end
|
||||
end
|
||||
|
||||
def test_data_should_be_loaded_correctly_when_in_readonly_mode
|
||||
@yamlstore.transaction do
|
||||
@yamlstore[:foo] = "bar"
|
||||
@yamlstore["foo"] = "bar"
|
||||
end
|
||||
@yamlstore.transaction(true) do
|
||||
assert_equal "bar", @yamlstore[:foo]
|
||||
assert_equal "bar", @yamlstore["foo"]
|
||||
end
|
||||
end
|
||||
|
||||
def test_data_should_be_loaded_correctly_when_in_readwrite_mode
|
||||
@yamlstore.transaction do
|
||||
@yamlstore[:foo] = "bar"
|
||||
@yamlstore["foo"] = "bar"
|
||||
end
|
||||
@yamlstore.transaction do
|
||||
assert_equal "bar", @yamlstore[:foo]
|
||||
assert_equal "bar", @yamlstore["foo"]
|
||||
end
|
||||
end
|
||||
|
||||
def test_changes_after_commit_are_discarded
|
||||
@yamlstore.transaction do
|
||||
@yamlstore[:foo] = "bar"
|
||||
@yamlstore["foo"] = "bar"
|
||||
@yamlstore.commit
|
||||
@yamlstore[:foo] = "baz"
|
||||
@yamlstore["foo"] = "baz"
|
||||
end
|
||||
@yamlstore.transaction(true) do
|
||||
assert_equal "bar", @yamlstore[:foo]
|
||||
assert_equal "bar", @yamlstore["foo"]
|
||||
end
|
||||
end
|
||||
|
||||
def test_changes_are_not_written_on_abort
|
||||
@yamlstore.transaction do
|
||||
@yamlstore[:foo] = "bar"
|
||||
@yamlstore["foo"] = "bar"
|
||||
@yamlstore.abort
|
||||
end
|
||||
@yamlstore.transaction(true) do
|
||||
assert_nil @yamlstore[:foo]
|
||||
assert_nil @yamlstore["foo"]
|
||||
end
|
||||
end
|
||||
|
||||
def test_writing_inside_readonly_transaction_raises_error
|
||||
assert_raises(PStore::Error) do
|
||||
assert_raise(PStore::Error) do
|
||||
@yamlstore.transaction(true) do
|
||||
@yamlstore[:foo] = "bar"
|
||||
@yamlstore["foo"] = "bar"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
@ -20,13 +20,13 @@ module Psych
|
|||
end
|
||||
|
||||
def test_tz_00_00_loads_without_error
|
||||
assert Psych.load('1900-01-01T00:00:00+00:00')
|
||||
assert Psych.unsafe_load('1900-01-01T00:00:00+00:00')
|
||||
end
|
||||
|
||||
def test_legacy_struct
|
||||
Struct.send(:remove_const, :AWESOME) if Struct.const_defined?(:AWESOME)
|
||||
foo = Struct.new('AWESOME', :bar)
|
||||
assert_equal foo.new('baz'), Psych.load(<<-eoyml)
|
||||
assert_equal foo.new('baz'), Psych.unsafe_load(<<-eoyml)
|
||||
!ruby/struct:AWESOME
|
||||
bar: baz
|
||||
eoyml
|
||||
|
|
|
@ -62,19 +62,19 @@ module Psych
|
|||
|
||||
def test_struct_anon
|
||||
s = Struct.new(:foo).new('bar')
|
||||
obj = Psych.load(Psych.dump(s))
|
||||
obj = Psych.unsafe_load(Psych.dump(s))
|
||||
assert_equal s.foo, obj.foo
|
||||
end
|
||||
|
||||
def test_override_method
|
||||
s = Struct.new(:method).new('override')
|
||||
obj = Psych.load(Psych.dump(s))
|
||||
obj = Psych.unsafe_load(Psych.dump(s))
|
||||
assert_equal s.method, obj.method
|
||||
end
|
||||
|
||||
def test_exception
|
||||
ex = Exception.new 'foo'
|
||||
loaded = Psych.load(Psych.dump(ex))
|
||||
loaded = Psych.unsafe_load(Psych.dump(ex))
|
||||
|
||||
assert_equal ex.message, loaded.message
|
||||
assert_equal ex.class, loaded.class
|
||||
|
@ -88,7 +88,7 @@ module Psych
|
|||
|
||||
def test_time
|
||||
t = Time.now
|
||||
assert_equal t, Psych.load(Psych.dump(t))
|
||||
assert_equal t, Psych.unsafe_load(Psych.dump(t))
|
||||
end
|
||||
|
||||
def test_date
|
||||
|
@ -127,11 +127,11 @@ module Psych
|
|||
end
|
||||
|
||||
def test_anon_class
|
||||
assert_raises(TypeError) do
|
||||
assert_raise(TypeError) do
|
||||
@v.accept Class.new
|
||||
end
|
||||
|
||||
assert_raises(TypeError) do
|
||||
assert_raise(TypeError) do
|
||||
Psych.dump(Class.new)
|
||||
end
|
||||
end
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue