mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
Merge psych-3.1.0.pre1.
* Update bundled libyaml-0.2.1 from 0.1.7.
https://github.com/ruby/psych/pull/368
* Unify Psych's API: To use keyword arguments with method call.
https://github.com/ruby/psych/pull/358
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@64544 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
hsbt
parent
e0311eb847
commit
867581dd75
16 changed files with 507 additions and 132 deletions
|
|
@ -230,14 +230,16 @@ require 'psych/class_loader'
|
|||
module Psych
|
||||
# The version of libyaml Psych is using
|
||||
LIBYAML_VERSION = Psych.libyaml_version.join '.'
|
||||
|
||||
FALLBACK = Struct.new :to_ruby # :nodoc:
|
||||
# Deprecation guard
|
||||
NOT_GIVEN = Object.new
|
||||
private_constant :NOT_GIVEN
|
||||
|
||||
###
|
||||
# Load +yaml+ in to a Ruby data structure. If multiple documents are
|
||||
# provided, the object contained in the first document will be returned.
|
||||
# +filename+ will be used in the exception message if any exception is raised
|
||||
# while parsing.
|
||||
# +filename+ will be used in the exception message if any exception
|
||||
# is raised while parsing. If +yaml+ is empty, it returns
|
||||
# the specified +fallback+ return value, which defaults to +false+.
|
||||
#
|
||||
# Raises a Psych::SyntaxError when a YAML syntax error is detected.
|
||||
#
|
||||
|
|
@ -247,7 +249,7 @@ module Psych
|
|||
# Psych.load("---\n - a\n - b") # => ['a', 'b']
|
||||
#
|
||||
# begin
|
||||
# Psych.load("--- `", "file.txt")
|
||||
# Psych.load("--- `", filename: "file.txt")
|
||||
# rescue Psych::SyntaxError => ex
|
||||
# ex.file # => 'file.txt'
|
||||
# ex.message # => "(file.txt): found character that cannot start any token"
|
||||
|
|
@ -259,8 +261,15 @@ module Psych
|
|||
# Psych.load("---\n foo: bar") # => {"foo"=>"bar"}
|
||||
# Psych.load("---\n foo: bar", symbolize_names: true) # => {:foo=>"bar"}
|
||||
#
|
||||
def self.load yaml, filename = nil, fallback: false, symbolize_names: false
|
||||
result = parse(yaml, filename, fallback: fallback)
|
||||
# Raises a TypeError when `yaml` parameter is NilClass
|
||||
#
|
||||
def self.load yaml, legacy_filename = NOT_GIVEN, filename: nil, fallback: false, symbolize_names: false
|
||||
if legacy_filename != NOT_GIVEN
|
||||
filename = legacy_filename
|
||||
end
|
||||
|
||||
result = parse(yaml, filename: filename)
|
||||
return fallback unless result
|
||||
result = result.to_ruby if result
|
||||
symbolize_names!(result) if symbolize_names
|
||||
result
|
||||
|
|
@ -279,27 +288,27 @@ module Psych
|
|||
# * Hash
|
||||
#
|
||||
# Recursive data structures are not allowed by default. Arbitrary classes
|
||||
# can be allowed by adding those classes to the +whitelist+. They are
|
||||
# can be allowed by adding those classes to the +whitelist_classes+ keyword argument. They are
|
||||
# additive. For example, to allow Date deserialization:
|
||||
#
|
||||
# Psych.safe_load(yaml, [Date])
|
||||
# Psych.safe_load(yaml, whitelist_classes: [Date])
|
||||
#
|
||||
# Now the Date class can be loaded in addition to the classes listed above.
|
||||
#
|
||||
# Aliases can be explicitly allowed by changing the +aliases+ parameter.
|
||||
# Aliases can be explicitly allowed by changing the +aliases+ keyword argument.
|
||||
# For example:
|
||||
#
|
||||
# x = []
|
||||
# x << x
|
||||
# yaml = Psych.dump x
|
||||
# Psych.safe_load yaml # => raises an exception
|
||||
# Psych.safe_load yaml, [], [], true # => loads the aliases
|
||||
# Psych.safe_load yaml, aliases: true # => loads the aliases
|
||||
#
|
||||
# A Psych::DisallowedClass exception will be raised if the yaml contains a
|
||||
# class that isn't in the whitelist.
|
||||
#
|
||||
# A Psych::BadAlias exception will be raised if the yaml contains aliases
|
||||
# but the +aliases+ parameter is set to false.
|
||||
# but the +aliases+ keyword argument is set to false.
|
||||
#
|
||||
# +filename+ will be used in the exception message if any exception is raised
|
||||
# while parsing.
|
||||
|
|
@ -310,18 +319,34 @@ module Psych
|
|||
# Psych.safe_load("---\n foo: bar") # => {"foo"=>"bar"}
|
||||
# Psych.safe_load("---\n foo: bar", symbolize_names: true) # => {:foo=>"bar"}
|
||||
#
|
||||
def self.safe_load yaml, whitelist_classes = [], whitelist_symbols = [], aliases = false, filename = nil, symbolize_names: false
|
||||
result = parse(yaml, filename)
|
||||
return unless result
|
||||
def self.safe_load yaml, legacy_whitelist_classes = NOT_GIVEN, legacy_whitelist_symbols = NOT_GIVEN, legacy_aliases = NOT_GIVEN, legacy_filename = NOT_GIVEN, whitelist_classes: [], whitelist_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false
|
||||
if legacy_whitelist_classes != NOT_GIVEN
|
||||
whitelist_classes = legacy_whitelist_classes
|
||||
end
|
||||
|
||||
if legacy_whitelist_symbols != NOT_GIVEN
|
||||
whitelist_symbols = legacy_whitelist_symbols
|
||||
end
|
||||
|
||||
if legacy_aliases != NOT_GIVEN
|
||||
aliases = legacy_aliases
|
||||
end
|
||||
|
||||
if legacy_filename != NOT_GIVEN
|
||||
filename = legacy_filename
|
||||
end
|
||||
|
||||
result = parse(yaml, filename: filename)
|
||||
return fallback unless result
|
||||
|
||||
class_loader = ClassLoader::Restricted.new(whitelist_classes.map(&:to_s),
|
||||
whitelist_symbols.map(&:to_s))
|
||||
scanner = ScalarScanner.new class_loader
|
||||
if aliases
|
||||
visitor = Visitors::ToRuby.new scanner, class_loader
|
||||
else
|
||||
visitor = Visitors::NoAliasRuby.new scanner, class_loader
|
||||
end
|
||||
visitor = if aliases
|
||||
Visitors::ToRuby.new scanner, class_loader
|
||||
else
|
||||
Visitors::NoAliasRuby.new scanner, class_loader
|
||||
end
|
||||
result = visitor.accept result
|
||||
symbolize_names!(result) if symbolize_names
|
||||
result
|
||||
|
|
@ -339,28 +364,38 @@ module Psych
|
|||
# Psych.parse("---\n - a\n - b") # => #<Psych::Nodes::Document:0x00>
|
||||
#
|
||||
# begin
|
||||
# Psych.parse("--- `", "file.txt")
|
||||
# Psych.parse("--- `", filename: "file.txt")
|
||||
# rescue Psych::SyntaxError => ex
|
||||
# ex.file # => 'file.txt'
|
||||
# ex.message # => "(file.txt): found character that cannot start any token"
|
||||
# end
|
||||
#
|
||||
# See Psych::Nodes for more information about YAML AST.
|
||||
def self.parse yaml, filename = nil, fallback: false
|
||||
parse_stream(yaml, filename) do |node|
|
||||
def self.parse yaml, legacy_filename = NOT_GIVEN, filename: nil, fallback: NOT_GIVEN
|
||||
if legacy_filename != NOT_GIVEN
|
||||
filename = legacy_filename
|
||||
end
|
||||
|
||||
parse_stream(yaml, filename: filename) do |node|
|
||||
return node
|
||||
end
|
||||
fallback
|
||||
|
||||
if fallback != NOT_GIVEN
|
||||
fallback
|
||||
else
|
||||
false
|
||||
end
|
||||
end
|
||||
|
||||
###
|
||||
# Parse a file at +filename+. Returns the Psych::Nodes::Document.
|
||||
#
|
||||
# Raises a Psych::SyntaxError when a YAML syntax error is detected.
|
||||
def self.parse_file filename
|
||||
File.open filename, 'r:bom|utf-8' do |f|
|
||||
parse f, filename
|
||||
def self.parse_file filename, fallback: false
|
||||
result = File.open filename, 'r:bom|utf-8' do |f|
|
||||
parse f, filename: filename
|
||||
end
|
||||
result || fallback
|
||||
end
|
||||
|
||||
###
|
||||
|
|
@ -389,14 +424,20 @@ module Psych
|
|||
# end
|
||||
#
|
||||
# begin
|
||||
# Psych.parse_stream("--- `", "file.txt")
|
||||
# Psych.parse_stream("--- `", filename: "file.txt")
|
||||
# rescue Psych::SyntaxError => ex
|
||||
# ex.file # => 'file.txt'
|
||||
# ex.message # => "(file.txt): found character that cannot start any token"
|
||||
# end
|
||||
#
|
||||
# Raises a TypeError when NilClass is passed.
|
||||
#
|
||||
# See Psych::Nodes for more information about YAML AST.
|
||||
def self.parse_stream yaml, filename = nil, &block
|
||||
def self.parse_stream yaml, legacy_filename = NOT_GIVEN, filename: nil, &block
|
||||
if legacy_filename != NOT_GIVEN
|
||||
filename = legacy_filename
|
||||
end
|
||||
|
||||
if block_given?
|
||||
parser = Psych::Parser.new(Handlers::DocumentStream.new(&block))
|
||||
parser.parse yaml, filename
|
||||
|
|
@ -497,14 +538,21 @@ module Psych
|
|||
# end
|
||||
# list # => ['foo', 'bar']
|
||||
#
|
||||
def self.load_stream yaml, filename = nil
|
||||
if block_given?
|
||||
parse_stream(yaml, filename) do |node|
|
||||
yield node.to_ruby
|
||||
end
|
||||
else
|
||||
parse_stream(yaml, filename).children.map { |child| child.to_ruby }
|
||||
def self.load_stream yaml, legacy_filename = NOT_GIVEN, filename: nil, fallback: []
|
||||
if legacy_filename != NOT_GIVEN
|
||||
filename = legacy_filename
|
||||
end
|
||||
|
||||
result = if block_given?
|
||||
parse_stream(yaml, filename: filename) do |node|
|
||||
yield node.to_ruby
|
||||
end
|
||||
else
|
||||
parse_stream(yaml, filename: filename).children.map(&:to_ruby)
|
||||
end
|
||||
|
||||
return fallback if result.is_a?(Array) && result.empty?
|
||||
result
|
||||
end
|
||||
|
||||
###
|
||||
|
|
@ -513,7 +561,7 @@ module Psych
|
|||
# the specified +fallback+ return value, which defaults to +false+.
|
||||
def self.load_file filename, fallback: false
|
||||
File.open(filename, 'r:bom|utf-8') { |f|
|
||||
self.load f, filename, fallback: FALLBACK.new(fallback)
|
||||
self.load f, filename: filename, fallback: fallback
|
||||
}
|
||||
end
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
# frozen_string_literal: true
|
||||
module Psych
|
||||
# The version is Psych you're using
|
||||
VERSION = '3.0.3.pre1'
|
||||
VERSION = '3.1.0.pre1'
|
||||
|
||||
if RUBY_ENGINE == 'jruby'
|
||||
DEFAULT_SNAKEYAML_VERSION = '1.21'.freeze
|
||||
|
|
|
|||
|
|
@ -1,9 +1,15 @@
|
|||
# -*- encoding: utf-8 -*-
|
||||
# frozen_string_literal: true
|
||||
|
||||
begin
|
||||
require_relative 'lib/psych/versions'
|
||||
rescue LoadError
|
||||
require_relative 'versions'
|
||||
end
|
||||
|
||||
Gem::Specification.new do |s|
|
||||
s.name = "psych"
|
||||
s.version = "3.0.3.pre1"
|
||||
s.version = Psych::VERSION
|
||||
s.authors = ["Aaron Patterson", "SHIBATA Hiroshi", "Charles Oliver Nutter"]
|
||||
s.email = ["aaron@tenderlovemaking.com", "hsbt@ruby-lang.org", "headius@headius.com"]
|
||||
s.summary = "Psych is a YAML parser and emitter"
|
||||
|
|
@ -53,7 +59,7 @@ DESCRIPTION
|
|||
"ext/java/PsychEmitter.java", "ext/java/PsychLibrary.java", "ext/java/PsychParser.java", "ext/java/PsychToRuby.java",
|
||||
"ext/java/PsychYamlTree.java", "lib/psych_jars.rb", "lib/psych.jar"
|
||||
]
|
||||
s.requirements = "jar org.yaml:snakeyaml, 1.21"
|
||||
s.requirements = "jar org.yaml:snakeyaml, #{Psych::DEFAULT_SNAKEYAML_VERSION}"
|
||||
s.add_dependency 'jar-dependencies', '>= 0.1.7'
|
||||
s.add_development_dependency 'ruby-maven'
|
||||
else
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ YAML_DECLARE(int)
|
|||
yaml_string_extend(yaml_char_t **start,
|
||||
yaml_char_t **pointer, yaml_char_t **end)
|
||||
{
|
||||
yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2);
|
||||
yaml_char_t *new_start = (yaml_char_t *)yaml_realloc((void*)*start, (*end - *start)*2);
|
||||
|
||||
if (!new_start) return 0;
|
||||
|
||||
|
|
@ -94,8 +94,9 @@ yaml_string_extend(yaml_char_t **start,
|
|||
YAML_DECLARE(int)
|
||||
yaml_string_join(
|
||||
yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
|
||||
yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end)
|
||||
yaml_char_t **b_start, yaml_char_t **b_pointer, SHIM(yaml_char_t **b_end))
|
||||
{
|
||||
UNUSED_PARAM(b_end)
|
||||
if (*b_start == *b_pointer)
|
||||
return 1;
|
||||
|
||||
|
|
@ -177,17 +178,17 @@ yaml_parser_initialize(yaml_parser_t *parser)
|
|||
goto error;
|
||||
if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
|
||||
goto error;
|
||||
if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE))
|
||||
if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE, yaml_token_t*))
|
||||
goto error;
|
||||
if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(parser, parser->indents, int*))
|
||||
goto error;
|
||||
if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(parser, parser->simple_keys, yaml_simple_key_t*))
|
||||
goto error;
|
||||
if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(parser, parser->states, yaml_parser_state_t*))
|
||||
goto error;
|
||||
if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(parser, parser->marks, yaml_mark_t*))
|
||||
goto error;
|
||||
if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(parser, parser->tag_directives, yaml_tag_directive_t*))
|
||||
goto error;
|
||||
|
||||
return 1;
|
||||
|
|
@ -243,7 +244,7 @@ static int
|
|||
yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
|
||||
size_t *size_read)
|
||||
{
|
||||
yaml_parser_t *parser = data;
|
||||
yaml_parser_t *parser = (yaml_parser_t *)data;
|
||||
|
||||
if (parser->input.string.current == parser->input.string.end) {
|
||||
*size_read = 0;
|
||||
|
|
@ -269,7 +270,7 @@ static int
|
|||
yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
|
||||
size_t *size_read)
|
||||
{
|
||||
yaml_parser_t *parser = data;
|
||||
yaml_parser_t *parser = (yaml_parser_t *)data;
|
||||
|
||||
*size_read = fread(buffer, 1, size, parser->input.file);
|
||||
return !ferror(parser->input.file);
|
||||
|
|
@ -355,13 +356,13 @@ yaml_emitter_initialize(yaml_emitter_t *emitter)
|
|||
goto error;
|
||||
if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
|
||||
goto error;
|
||||
if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(emitter, emitter->states, yaml_emitter_state_t*))
|
||||
goto error;
|
||||
if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE))
|
||||
if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE, yaml_event_t*))
|
||||
goto error;
|
||||
if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(emitter, emitter->indents, int*))
|
||||
goto error;
|
||||
if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(emitter, emitter->tag_directives, yaml_tag_directive_t*))
|
||||
goto error;
|
||||
|
||||
return 1;
|
||||
|
|
@ -413,7 +414,7 @@ yaml_emitter_delete(yaml_emitter_t *emitter)
|
|||
static int
|
||||
yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
|
||||
{
|
||||
yaml_emitter_t *emitter = data;
|
||||
yaml_emitter_t *emitter = (yaml_emitter_t *)data;
|
||||
|
||||
if (emitter->output.string.size - *emitter->output.string.size_written
|
||||
< size) {
|
||||
|
|
@ -439,7 +440,7 @@ yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
|
|||
static int
|
||||
yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
|
||||
{
|
||||
yaml_emitter_t *emitter = data;
|
||||
yaml_emitter_t *emitter = (yaml_emitter_t *)data;
|
||||
|
||||
return (fwrite(buffer, 1, size, emitter->output.file) == size);
|
||||
}
|
||||
|
|
@ -717,7 +718,7 @@ yaml_document_start_event_initialize(yaml_event_t *event,
|
|||
/* Valid tag directives are expected. */
|
||||
|
||||
if (version_directive) {
|
||||
version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
|
||||
version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
|
||||
if (!version_directive_copy) goto error;
|
||||
version_directive_copy->major = version_directive->major;
|
||||
version_directive_copy->minor = version_directive->minor;
|
||||
|
|
@ -725,7 +726,7 @@ yaml_document_start_event_initialize(yaml_event_t *event,
|
|||
|
||||
if (tag_directives_start != tag_directives_end) {
|
||||
yaml_tag_directive_t *tag_directive;
|
||||
if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
|
||||
goto error;
|
||||
for (tag_directive = tag_directives_start;
|
||||
tag_directive != tag_directives_end; tag_directive ++) {
|
||||
|
|
@ -843,7 +844,7 @@ yaml_scalar_event_initialize(yaml_event_t *event,
|
|||
}
|
||||
|
||||
if (!yaml_check_utf8(value, length)) goto error;
|
||||
value_copy = yaml_malloc(length+1);
|
||||
value_copy = YAML_MALLOC(length+1);
|
||||
if (!value_copy) goto error;
|
||||
memcpy(value_copy, value, length);
|
||||
value_copy[length] = '\0';
|
||||
|
|
@ -1055,10 +1056,10 @@ yaml_document_initialize(yaml_document_t *document,
|
|||
(tag_directives_start == tag_directives_end));
|
||||
/* Valid tag directives are expected. */
|
||||
|
||||
if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error;
|
||||
if (!STACK_INIT(&context, nodes, yaml_node_t*)) goto error;
|
||||
|
||||
if (version_directive) {
|
||||
version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
|
||||
version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
|
||||
if (!version_directive_copy) goto error;
|
||||
version_directive_copy->major = version_directive->major;
|
||||
version_directive_copy->minor = version_directive->minor;
|
||||
|
|
@ -1066,7 +1067,7 @@ yaml_document_initialize(yaml_document_t *document,
|
|||
|
||||
if (tag_directives_start != tag_directives_end) {
|
||||
yaml_tag_directive_t *tag_directive;
|
||||
if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
|
||||
goto error;
|
||||
for (tag_directive = tag_directives_start;
|
||||
tag_directive != tag_directives_end; tag_directive ++) {
|
||||
|
|
@ -1219,7 +1220,7 @@ yaml_document_add_scalar(yaml_document_t *document,
|
|||
}
|
||||
|
||||
if (!yaml_check_utf8(value, length)) goto error;
|
||||
value_copy = yaml_malloc(length+1);
|
||||
value_copy = YAML_MALLOC(length+1);
|
||||
if (!value_copy) goto error;
|
||||
memcpy(value_copy, value, length);
|
||||
value_copy[length] = '\0';
|
||||
|
|
@ -1266,7 +1267,7 @@ yaml_document_add_sequence(yaml_document_t *document,
|
|||
tag_copy = yaml_strdup(tag);
|
||||
if (!tag_copy) goto error;
|
||||
|
||||
if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error;
|
||||
if (!STACK_INIT(&context, items, yaml_node_item_t*)) goto error;
|
||||
|
||||
SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
|
||||
style, mark, mark);
|
||||
|
|
@ -1311,7 +1312,7 @@ yaml_document_add_mapping(yaml_document_t *document,
|
|||
tag_copy = yaml_strdup(tag);
|
||||
if (!tag_copy) goto error;
|
||||
|
||||
if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error;
|
||||
if (!STACK_INIT(&context, pairs, yaml_node_pair_t*)) goto error;
|
||||
|
||||
MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
|
||||
style, mark, mark);
|
||||
|
|
|
|||
|
|
@ -1,10 +1,10 @@
|
|||
#define PACKAGE_NAME "yaml"
|
||||
#define PACKAGE_TARNAME "yaml"
|
||||
#define PACKAGE_VERSION "0.1.7"
|
||||
#define PACKAGE_STRING "yaml 0.1.7"
|
||||
#define PACKAGE_VERSION "0.2.1"
|
||||
#define PACKAGE_STRING "yaml 0.2.1"
|
||||
#define PACKAGE_BUGREPORT "https://github.com/yaml/libyaml/issues"
|
||||
#define PACKAGE_URL "https://github.com/yaml/libyaml"
|
||||
#define YAML_VERSION_MAJOR 0
|
||||
#define YAML_VERSION_MINOR 1
|
||||
#define YAML_VERSION_PATCH 7
|
||||
#define YAML_VERSION_STRING "0.1.7"
|
||||
#define YAML_VERSION_MINOR 2
|
||||
#define YAML_VERSION_PATCH 1
|
||||
#define YAML_VERSION_STRING "0.2.1"
|
||||
|
|
|
|||
|
|
@ -245,9 +245,9 @@ yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index)
|
|||
#define ANCHOR_TEMPLATE_LENGTH 16
|
||||
|
||||
static yaml_char_t *
|
||||
yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id)
|
||||
yaml_emitter_generate_anchor(SHIM(yaml_emitter_t *emitter), int anchor_id)
|
||||
{
|
||||
yaml_char_t *anchor = yaml_malloc(ANCHOR_TEMPLATE_LENGTH);
|
||||
yaml_char_t *anchor = YAML_MALLOC(ANCHOR_TEMPLATE_LENGTH);
|
||||
|
||||
if (!anchor) return NULL;
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
*/
|
||||
|
||||
#define PUT_BREAK(emitter) \
|
||||
(FLUSH(emitter) ? \
|
||||
(FLUSH(emitter) ? \
|
||||
((emitter->line_break == YAML_CR_BREAK ? \
|
||||
(*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \
|
||||
emitter->line_break == YAML_LN_BREAK ? \
|
||||
|
|
@ -1002,7 +1002,7 @@ yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
|
|||
*/
|
||||
|
||||
static int
|
||||
yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event)
|
||||
yaml_emitter_emit_alias(yaml_emitter_t *emitter, SHIM(yaml_event_t *event))
|
||||
{
|
||||
if (!yaml_emitter_process_anchor(emitter))
|
||||
return 0;
|
||||
|
|
@ -1087,7 +1087,7 @@ yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event)
|
|||
*/
|
||||
|
||||
static int
|
||||
yaml_emitter_check_empty_document(yaml_emitter_t *emitter)
|
||||
yaml_emitter_check_empty_document(SHIM(yaml_emitter_t *emitter))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1946,10 +1946,6 @@ yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
|
|||
|
||||
emitter->whitespace = 0;
|
||||
emitter->indention = 0;
|
||||
if (emitter->root_context)
|
||||
{
|
||||
emitter->open_ended = 1;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -2326,4 +2322,3 @@ yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
|
|||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document)
|
|||
assert(document); /* Non-NULL document object is expected. */
|
||||
|
||||
memset(document, 0, sizeof(yaml_document_t));
|
||||
if (!STACK_INIT(parser, document->nodes, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(parser, document->nodes, yaml_node_t*))
|
||||
goto error;
|
||||
|
||||
if (!parser->stream_start_produced) {
|
||||
|
|
@ -90,7 +90,7 @@ yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document)
|
|||
return 1;
|
||||
}
|
||||
|
||||
if (!STACK_INIT(parser, parser->aliases, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(parser, parser->aliases, yaml_alias_data_t*))
|
||||
goto error;
|
||||
|
||||
parser->document = document;
|
||||
|
|
@ -339,7 +339,7 @@ yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event)
|
|||
if (!tag) goto error;
|
||||
}
|
||||
|
||||
if (!STACK_INIT(parser, items, INITIAL_STACK_SIZE)) goto error;
|
||||
if (!STACK_INIT(parser, items, yaml_node_item_t*)) goto error;
|
||||
|
||||
SEQUENCE_NODE_INIT(node, tag, items.start, items.end,
|
||||
first_event->data.sequence_start.style,
|
||||
|
|
@ -402,7 +402,7 @@ yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event)
|
|||
if (!tag) goto error;
|
||||
}
|
||||
|
||||
if (!STACK_INIT(parser, pairs, INITIAL_STACK_SIZE)) goto error;
|
||||
if (!STACK_INIT(parser, pairs, yaml_node_pair_t*)) goto error;
|
||||
|
||||
MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end,
|
||||
first_event->data.mapping_start.style,
|
||||
|
|
|
|||
|
|
@ -605,7 +605,7 @@ yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
|
|||
if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {
|
||||
size_t prefix_len = strlen((char *)tag_directive->prefix);
|
||||
size_t suffix_len = strlen((char *)tag_suffix);
|
||||
tag = yaml_malloc(prefix_len+suffix_len+1);
|
||||
tag = YAML_MALLOC(prefix_len+suffix_len+1);
|
||||
if (!tag) {
|
||||
parser->error = YAML_MEMORY_ERROR;
|
||||
goto error;
|
||||
|
|
@ -685,7 +685,7 @@ yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
|
|||
return 1;
|
||||
}
|
||||
else if (anchor || tag) {
|
||||
yaml_char_t *value = yaml_malloc(1);
|
||||
yaml_char_t *value = YAML_MALLOC(1);
|
||||
if (!value) {
|
||||
parser->error = YAML_MEMORY_ERROR;
|
||||
goto error;
|
||||
|
|
@ -1208,7 +1208,7 @@ yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event,
|
|||
{
|
||||
yaml_char_t *value;
|
||||
|
||||
value = yaml_malloc(1);
|
||||
value = YAML_MALLOC(1);
|
||||
if (!value) {
|
||||
parser->error = YAML_MEMORY_ERROR;
|
||||
return 0;
|
||||
|
|
@ -1245,7 +1245,7 @@ yaml_parser_process_directives(yaml_parser_t *parser,
|
|||
} tag_directives = { NULL, NULL, NULL };
|
||||
yaml_token_t *token;
|
||||
|
||||
if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE))
|
||||
if (!STACK_INIT(parser, tag_directives, yaml_tag_directive_t*))
|
||||
goto error;
|
||||
|
||||
token = PEEK_TOKEN(parser);
|
||||
|
|
@ -1266,7 +1266,7 @@ yaml_parser_process_directives(yaml_parser_t *parser,
|
|||
"found incompatible YAML document", token->start_mark);
|
||||
goto error;
|
||||
}
|
||||
version_directive = yaml_malloc(sizeof(yaml_version_directive_t));
|
||||
version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t);
|
||||
if (!version_directive) {
|
||||
parser->error = YAML_MEMORY_ERROR;
|
||||
goto error;
|
||||
|
|
|
|||
|
|
@ -460,10 +460,10 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
|
|||
|
||||
}
|
||||
|
||||
if (parser->offset >= PTRDIFF_MAX)
|
||||
if (parser->offset >= MAX_FILE_SIZE) {
|
||||
return yaml_parser_set_reader_error(parser, "input is too long",
|
||||
PTRDIFF_MAX, -1);
|
||||
parser->offset, -1);
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1188,7 +1188,7 @@ yaml_parser_decrease_flow_level(yaml_parser_t *parser)
|
|||
{
|
||||
if (parser->flow_level) {
|
||||
parser->flow_level --;
|
||||
(void)POP(parser, parser->simple_keys);
|
||||
(void)POP(parser, parser->simple_keys);
|
||||
}
|
||||
|
||||
return 1;
|
||||
|
|
@ -2399,7 +2399,7 @@ yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)
|
|||
{
|
||||
/* Set the handle to '' */
|
||||
|
||||
handle = yaml_malloc(1);
|
||||
handle = YAML_MALLOC(1);
|
||||
if (!handle) goto error;
|
||||
handle[0] = '\0';
|
||||
|
||||
|
|
@ -2451,7 +2451,7 @@ yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)
|
|||
/* Set the handle to '!'. */
|
||||
|
||||
yaml_free(handle);
|
||||
handle = yaml_malloc(2);
|
||||
handle = YAML_MALLOC(2);
|
||||
if (!handle) goto error;
|
||||
handle[0] = '!';
|
||||
handle[1] = '\0';
|
||||
|
|
@ -3160,8 +3160,8 @@ yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token,
|
|||
*(string.pointer++) = '"';
|
||||
break;
|
||||
|
||||
case '\'':
|
||||
*(string.pointer++) = '\'';
|
||||
case '/':
|
||||
*(string.pointer++) = '/';
|
||||
break;
|
||||
|
||||
case '\\':
|
||||
|
|
@ -3278,6 +3278,11 @@ 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
|
||||
* Credit for the bug and input is to OSS Fuzz
|
||||
* Credit for the fix to Alex Gaynor
|
||||
*/
|
||||
if (!CACHE(parser, 1)) goto error;
|
||||
if (CHECK(parser->buffer, single ? '\'' : '"'))
|
||||
break;
|
||||
|
||||
|
|
@ -3507,7 +3512,7 @@ yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token)
|
|||
if (leading_blanks && (int)parser->mark.column < indent
|
||||
&& IS_TAB(parser->buffer)) {
|
||||
yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
|
||||
start_mark, "found a tab character that violates indentation");
|
||||
start_mark, "found a tab character that violate indentation");
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
|
@ -3571,4 +3576,3 @@ error:
|
|||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -12,16 +12,6 @@
|
|||
#include <limits.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#ifndef _MSC_VER
|
||||
#include <stdint.h>
|
||||
#else
|
||||
#ifdef _WIN64
|
||||
#define PTRDIFF_MAX _I64_MAX
|
||||
#else
|
||||
#define PTRDIFF_MAX INT_MAX
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Memory management.
|
||||
*/
|
||||
|
|
@ -80,6 +70,17 @@ yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
|
|||
|
||||
#define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2)
|
||||
|
||||
/*
|
||||
* The maximum size of a YAML input file.
|
||||
* This used to be PTRDIFF_MAX, but that's not entirely portable
|
||||
* because stdint.h isn't available on all platforms.
|
||||
* It is not entirely clear why this isn't the maximum value
|
||||
* that can fit into the parser->offset field.
|
||||
*/
|
||||
|
||||
#define MAX_FILE_SIZE (~(size_t)0 / 2)
|
||||
|
||||
|
||||
/*
|
||||
* The size of other stacks and queues.
|
||||
*/
|
||||
|
|
@ -93,7 +94,7 @@ yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
|
|||
*/
|
||||
|
||||
#define BUFFER_INIT(context,buffer,size) \
|
||||
(((buffer).start = yaml_malloc(size)) ? \
|
||||
(((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \
|
||||
((buffer).last = (buffer).pointer = (buffer).start, \
|
||||
(buffer).end = (buffer).start+(size), \
|
||||
1) : \
|
||||
|
|
@ -133,7 +134,7 @@ yaml_string_join(
|
|||
(value).pointer = (string))
|
||||
|
||||
#define STRING_INIT(context,string,size) \
|
||||
(((string).start = yaml_malloc(size)) ? \
|
||||
(((string).start = YAML_MALLOC(size)) ? \
|
||||
((string).pointer = (string).start, \
|
||||
(string).end = (string).start+(size), \
|
||||
memset((string).start, 0, (size)), \
|
||||
|
|
@ -423,10 +424,10 @@ yaml_stack_extend(void **start, void **top, void **end);
|
|||
YAML_DECLARE(int)
|
||||
yaml_queue_extend(void **start, void **head, void **tail, void **end);
|
||||
|
||||
#define STACK_INIT(context,stack,size) \
|
||||
(((stack).start = yaml_malloc((size)*sizeof(*(stack).start))) ? \
|
||||
#define STACK_INIT(context,stack,type) \
|
||||
(((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \
|
||||
((stack).top = (stack).start, \
|
||||
(stack).end = (stack).start+(size), \
|
||||
(stack).end = (stack).start+INITIAL_STACK_SIZE, \
|
||||
1) : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
|
@ -456,8 +457,8 @@ yaml_queue_extend(void **start, void **head, void **tail, void **end);
|
|||
#define POP(context,stack) \
|
||||
(*(--(stack).top))
|
||||
|
||||
#define QUEUE_INIT(context,queue,size) \
|
||||
(((queue).start = yaml_malloc((size)*sizeof(*(queue).start))) ? \
|
||||
#define QUEUE_INIT(context,queue,size,type) \
|
||||
(((queue).start = (type)yaml_malloc((size)*sizeof(*(queue).start))) ? \
|
||||
((queue).head = (queue).tail = (queue).start, \
|
||||
(queue).end = (queue).start+(size), \
|
||||
1) : \
|
||||
|
|
@ -660,3 +661,28 @@ yaml_queue_extend(void **start, void **head, void **tail, void **end);
|
|||
(node).data.mapping.pairs.end = (node_pairs_end), \
|
||||
(node).data.mapping.pairs.top = (node_pairs_start), \
|
||||
(node).data.mapping.style = (node_style))
|
||||
|
||||
/* Strict C compiler warning helpers */
|
||||
|
||||
#if defined(__clang__) || defined(__GNUC__)
|
||||
# define HASATTRIBUTE_UNUSED
|
||||
#endif
|
||||
#ifdef HASATTRIBUTE_UNUSED
|
||||
# define __attribute__unused__ __attribute__((__unused__))
|
||||
#else
|
||||
# define __attribute__unused__
|
||||
#endif
|
||||
|
||||
/* Shim arguments are arguments that must be included in your function,
|
||||
* but serve no purpose inside. Silence compiler warnings. */
|
||||
#define SHIM(a) /*@unused@*/ a __attribute__unused__
|
||||
|
||||
/* UNUSED_PARAM() marks a shim argument in the body to silence compiler warnings */
|
||||
#ifdef __clang__
|
||||
# define UNUSED_PARAM(a) (void)(a);
|
||||
#else
|
||||
# define UNUSED_PARAM(a) /*@-noeffect*/if (0) (void)(a)/*@=noeffect*/;
|
||||
#endif
|
||||
|
||||
#define YAML_MALLOC_STATIC(type) (type*)yaml_malloc(sizeof(type))
|
||||
#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size)
|
||||
|
|
|
|||
|
|
@ -30,9 +30,15 @@ module Psych
|
|||
assert_nil ex.file
|
||||
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
Psych.load '--- `', 'meow'
|
||||
Psych.load '--- `', filename: 'meow'
|
||||
end
|
||||
assert_equal 'meow', ex.file
|
||||
|
||||
# deprecated interface
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
Psych.load '--- `', 'deprecated'
|
||||
end
|
||||
assert_equal 'deprecated', ex.file
|
||||
end
|
||||
|
||||
def test_psych_parse_stream_takes_file
|
||||
|
|
@ -43,7 +49,7 @@ module Psych
|
|||
assert_match '(<unknown>)', ex.message
|
||||
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
Psych.parse_stream '--- `', 'omg!'
|
||||
Psych.parse_stream '--- `', filename: 'omg!'
|
||||
end
|
||||
assert_equal 'omg!', ex.file
|
||||
assert_match 'omg!', ex.message
|
||||
|
|
@ -57,9 +63,15 @@ module Psych
|
|||
assert_match '(<unknown>)', ex.message
|
||||
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
Psych.load_stream '--- `', 'omg!'
|
||||
Psych.load_stream '--- `', filename: 'omg!'
|
||||
end
|
||||
assert_equal 'omg!', ex.file
|
||||
|
||||
# deprecated interface
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
Psych.load_stream '--- `', 'deprecated'
|
||||
end
|
||||
assert_equal 'deprecated', ex.file
|
||||
end
|
||||
|
||||
def test_parse_file_exception
|
||||
|
|
@ -94,9 +106,15 @@ module Psych
|
|||
assert_nil ex.file
|
||||
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
Psych.parse '--- `', 'omg!'
|
||||
Psych.parse '--- `', filename: 'omg!'
|
||||
end
|
||||
assert_match 'omg!', ex.message
|
||||
|
||||
# deprecated interface
|
||||
ex = assert_raises(Psych::SyntaxError) do
|
||||
Psych.parse '--- `', 'deprecated'
|
||||
end
|
||||
assert_match 'deprecated', ex.message
|
||||
end
|
||||
|
||||
def test_attributes
|
||||
|
|
|
|||
|
|
@ -60,6 +60,22 @@ class TestPsych < Psych::TestCase
|
|||
end
|
||||
end
|
||||
|
||||
def test_parse
|
||||
assert_equal %w[a b], Psych.parse("- a\n- b").to_ruby
|
||||
end
|
||||
|
||||
def test_parse_default_fallback
|
||||
assert_equal false, Psych.parse("")
|
||||
end
|
||||
|
||||
def test_parse_raises_on_bad_input
|
||||
assert_raises(Psych::SyntaxError) { Psych.parse("--- `") }
|
||||
end
|
||||
|
||||
def test_parse_with_fallback
|
||||
assert_equal 42, Psych.parse("", fallback: 42)
|
||||
end
|
||||
|
||||
def test_non_existing_class_on_deserialize
|
||||
e = assert_raises(ArgumentError) do
|
||||
Psych.load("--- !ruby/object:NonExistent\nfoo: 1")
|
||||
|
|
@ -103,9 +119,44 @@ class TestPsych < Psych::TestCase
|
|||
assert_equal %w{ foo bar }, docs
|
||||
end
|
||||
|
||||
def test_load_stream_default_fallback
|
||||
assert_equal [], Psych.load_stream("")
|
||||
end
|
||||
|
||||
def test_load_stream_raises_on_bad_input
|
||||
assert_raises(Psych::SyntaxError) { Psych.load_stream("--- `") }
|
||||
end
|
||||
|
||||
def test_parse_stream
|
||||
docs = Psych.parse_stream("--- foo\n...\n--- bar\n...")
|
||||
assert_equal %w{ foo bar }, docs.children.map { |x| x.transform }
|
||||
assert_equal(%w[foo bar], docs.children.map(&:transform))
|
||||
end
|
||||
|
||||
def test_parse_stream_with_block
|
||||
docs = []
|
||||
Psych.parse_stream("--- foo\n...\n--- bar\n...") do |node|
|
||||
docs << node
|
||||
end
|
||||
|
||||
assert_equal %w[foo bar], docs.map(&:to_ruby)
|
||||
end
|
||||
|
||||
def test_parse_stream_default_fallback
|
||||
docs = Psych.parse_stream("")
|
||||
assert_equal [], docs.children.map(&:to_ruby)
|
||||
end
|
||||
|
||||
def test_parse_stream_with_block_default_fallback
|
||||
docs = []
|
||||
Psych.parse_stream("") do |node|
|
||||
docs << node
|
||||
end
|
||||
|
||||
assert_equal [], docs.map(&:to_ruby)
|
||||
end
|
||||
|
||||
def test_parse_stream_raises_on_bad_input
|
||||
assert_raises(Psych::SyntaxError) { Psych.parse_stream("--- `") }
|
||||
end
|
||||
|
||||
def test_add_builtin_type
|
||||
|
|
@ -135,6 +186,31 @@ class TestPsych < Psych::TestCase
|
|||
assert_equal({ 'hello' => 'world' }, got)
|
||||
end
|
||||
|
||||
def test_load_default_fallback
|
||||
assert_equal false, Psych.load("")
|
||||
end
|
||||
|
||||
def test_load_with_fallback
|
||||
assert_equal 42, Psych.load("", "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)
|
||||
end
|
||||
|
||||
def test_load_with_fallback_hash
|
||||
assert_equal Hash.new, Psych.load("", "file", fallback: Hash.new)
|
||||
end
|
||||
|
||||
def test_load_with_fallback_for_nil
|
||||
assert_nil Psych.load("--- null", "file", fallback: 42)
|
||||
end
|
||||
|
||||
def test_load_with_fallback_for_false
|
||||
assert_equal false, Psych.load("--- false", "file", fallback: 42)
|
||||
end
|
||||
|
||||
def test_load_file
|
||||
Tempfile.create(['yikes', 'yml']) {|t|
|
||||
t.binmode
|
||||
|
|
@ -144,7 +220,7 @@ class TestPsych < Psych::TestCase
|
|||
}
|
||||
end
|
||||
|
||||
def test_load_file_default_return_value
|
||||
def test_load_file_default_fallback
|
||||
Tempfile.create(['empty', 'yml']) {|t|
|
||||
assert_equal false, Psych.load_file(t.path)
|
||||
}
|
||||
|
|
@ -196,6 +272,12 @@ class TestPsych < Psych::TestCase
|
|||
}
|
||||
end
|
||||
|
||||
def test_parse_file_default_fallback
|
||||
Tempfile.create(['empty', 'yml']) do |t|
|
||||
assert_equal false, Psych.parse_file(t.path)
|
||||
end
|
||||
end
|
||||
|
||||
def test_degenerate_strings
|
||||
assert_equal false, Psych.load(' ')
|
||||
assert_equal false, Psych.parse(' ')
|
||||
|
|
|
|||
|
|
@ -22,6 +22,8 @@ module Psych
|
|||
def test_explicit_recursion
|
||||
x = []
|
||||
x << x
|
||||
assert_equal(x, Psych.safe_load(Psych.dump(x), whitelist_classes: [], whitelist_symbols: [], aliases: true))
|
||||
# deprecated interface
|
||||
assert_equal(x, Psych.safe_load(Psych.dump(x), [], [], true))
|
||||
end
|
||||
|
||||
|
|
@ -30,6 +32,16 @@ module Psych
|
|||
assert_raises(Psych::DisallowedClass) do
|
||||
Psych.safe_load yml
|
||||
end
|
||||
assert_equal(
|
||||
:foo,
|
||||
Psych.safe_load(
|
||||
yml,
|
||||
whitelist_classes: [Symbol],
|
||||
whitelist_symbols: [:foo]
|
||||
)
|
||||
)
|
||||
|
||||
# deprecated interface
|
||||
assert_equal(:foo, Psych.safe_load(yml, [Symbol], [:foo]))
|
||||
end
|
||||
|
||||
|
|
@ -37,33 +49,72 @@ module Psych
|
|||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_safe_cycle :foo
|
||||
end
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
Psych.safe_load '--- !ruby/symbol foo', whitelist_classes: []
|
||||
end
|
||||
|
||||
# deprecated interface
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
Psych.safe_load '--- !ruby/symbol foo', []
|
||||
end
|
||||
assert_safe_cycle :foo, [Symbol]
|
||||
assert_safe_cycle :foo, %w{ Symbol }
|
||||
|
||||
assert_safe_cycle :foo, whitelist_classes: [Symbol]
|
||||
assert_safe_cycle :foo, whitelist_classes: %w{ Symbol }
|
||||
assert_equal :foo, Psych.safe_load('--- !ruby/symbol foo', whitelist_classes: [Symbol])
|
||||
|
||||
# deprecated interface
|
||||
assert_equal :foo, Psych.safe_load('--- !ruby/symbol foo', [Symbol])
|
||||
end
|
||||
|
||||
def test_foo
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
Psych.safe_load '--- !ruby/object:Foo {}', whitelist_classes: [Foo]
|
||||
end
|
||||
|
||||
# deprecated interface
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
Psych.safe_load '--- !ruby/object:Foo {}', [Foo]
|
||||
end
|
||||
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
assert_safe_cycle Foo.new
|
||||
end
|
||||
assert_kind_of(Foo, Psych.safe_load(Psych.dump(Foo.new), whitelist_classes: [Foo]))
|
||||
|
||||
# deprecated interface
|
||||
assert_kind_of(Foo, Psych.safe_load(Psych.dump(Foo.new), [Foo]))
|
||||
end
|
||||
|
||||
X = Struct.new(:x)
|
||||
def test_struct_depends_on_sym
|
||||
assert_safe_cycle(X.new, [X, Symbol])
|
||||
assert_safe_cycle(X.new, whitelist_classes: [X, Symbol])
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
cycle X.new, [X]
|
||||
cycle X.new, whitelist_classes: [X]
|
||||
end
|
||||
end
|
||||
|
||||
def test_anon_struct
|
||||
assert Psych.safe_load(<<-eoyml, whitelist_classes: [Struct, Symbol])
|
||||
--- !ruby/struct
|
||||
foo: bar
|
||||
eoyml
|
||||
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
Psych.safe_load(<<-eoyml, whitelist_classes: [Struct])
|
||||
--- !ruby/struct
|
||||
foo: bar
|
||||
eoyml
|
||||
end
|
||||
|
||||
assert_raises(Psych::DisallowedClass) do
|
||||
Psych.safe_load(<<-eoyml, whitelist_classes: [Symbol])
|
||||
--- !ruby/struct
|
||||
foo: bar
|
||||
eoyml
|
||||
end
|
||||
end
|
||||
|
||||
def test_deprecated_anon_struct
|
||||
assert Psych.safe_load(<<-eoyml, [Struct, Symbol])
|
||||
--- !ruby/struct
|
||||
foo: bar
|
||||
|
|
@ -84,14 +135,28 @@ module Psych
|
|||
end
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def cycle object, whitelist = []
|
||||
Psych.safe_load(Psych.dump(object), whitelist)
|
||||
def test_safe_load_default_fallback
|
||||
assert_nil Psych.safe_load("")
|
||||
end
|
||||
|
||||
def assert_safe_cycle object, whitelist = []
|
||||
other = cycle object, whitelist
|
||||
def test_safe_load
|
||||
assert_equal %w[a b], Psych.safe_load("- a\n- b")
|
||||
end
|
||||
|
||||
def test_safe_load_raises_on_bad_input
|
||||
assert_raises(Psych::SyntaxError) { Psych.safe_load("--- `") }
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def cycle object, whitelist_classes: []
|
||||
Psych.safe_load(Psych.dump(object), whitelist_classes: whitelist_classes)
|
||||
# deprecated interface test
|
||||
Psych.safe_load(Psych.dump(object), whitelist_classes)
|
||||
end
|
||||
|
||||
def assert_safe_cycle object, whitelist_classes: []
|
||||
other = cycle object, whitelist_classes: whitelist_classes
|
||||
assert_equal object, other
|
||||
end
|
||||
end
|
||||
|
|
|
|||
130
test/psych/test_yaml_special_cases.rb
Normal file
130
test/psych/test_yaml_special_cases.rb
Normal file
|
|
@ -0,0 +1,130 @@
|
|||
# frozen_string_literal: true
|
||||
|
||||
require_relative 'helper'
|
||||
|
||||
require 'stringio'
|
||||
require 'tempfile'
|
||||
|
||||
module Psych
|
||||
class TestYamlSpecialCases < TestCase
|
||||
def setup
|
||||
super
|
||||
end
|
||||
|
||||
def test_empty_string
|
||||
s = ""
|
||||
assert_equal false, Psych.load(s)
|
||||
assert_equal [], Psych.load_stream(s)
|
||||
assert_equal false, Psych.parse(s)
|
||||
assert_equal [], Psych.parse_stream(s).transform
|
||||
assert_equal nil, Psych.safe_load(s)
|
||||
end
|
||||
|
||||
def test_false
|
||||
s = "false"
|
||||
assert_equal false, Psych.load(s)
|
||||
assert_equal [false], Psych.load_stream(s)
|
||||
assert_equal false, Psych.parse(s).transform
|
||||
assert_equal [false], Psych.parse_stream(s).transform
|
||||
assert_equal false, Psych.safe_load(s)
|
||||
end
|
||||
|
||||
def test_n
|
||||
s = "n"
|
||||
assert_equal "n", Psych.load(s)
|
||||
assert_equal ["n"], Psych.load_stream(s)
|
||||
assert_equal "n", Psych.parse(s).transform
|
||||
assert_equal ["n"], Psych.parse_stream(s).transform
|
||||
assert_equal "n", Psych.safe_load(s)
|
||||
end
|
||||
|
||||
def test_off
|
||||
s = "off"
|
||||
assert_equal false, Psych.load(s)
|
||||
assert_equal [false], Psych.load_stream(s)
|
||||
assert_equal false, Psych.parse(s).transform
|
||||
assert_equal [false], Psych.parse_stream(s).transform
|
||||
assert_equal false, Psych.safe_load(s)
|
||||
end
|
||||
|
||||
def test_inf
|
||||
s = "-.inf"
|
||||
assert_equal -Float::INFINITY, Psych.load(s)
|
||||
assert_equal [-Float::INFINITY], Psych.load_stream(s)
|
||||
assert_equal -Float::INFINITY, Psych.parse(s).transform
|
||||
assert_equal [-Float::INFINITY], Psych.parse_stream(s).transform
|
||||
assert_equal -Float::INFINITY, Psych.safe_load(s)
|
||||
end
|
||||
|
||||
def test_NaN
|
||||
s = ".NaN"
|
||||
assert Float::NAN, Psych.load(s).nan?
|
||||
assert [Float::NAN], 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?
|
||||
end
|
||||
|
||||
def test_0xC
|
||||
s = "0xC"
|
||||
assert_equal 12, Psych.load(s)
|
||||
assert_equal [12], Psych.load_stream(s)
|
||||
assert_equal 12, Psych.parse(s).transform
|
||||
assert_equal [12], Psych.parse_stream(s).transform
|
||||
assert_equal 12, Psych.safe_load(s)
|
||||
end
|
||||
|
||||
def test_arrows
|
||||
s = "<<"
|
||||
assert_equal "<<", Psych.load(s)
|
||||
assert_equal ["<<"], Psych.load_stream(s)
|
||||
assert_equal "<<", Psych.parse(s).transform
|
||||
assert_equal ["<<"], Psych.parse_stream(s).transform
|
||||
assert_equal "<<", Psych.safe_load(s)
|
||||
end
|
||||
|
||||
def test_arrows_hash
|
||||
s = "<<: {}"
|
||||
assert_equal({}, Psych.load(s))
|
||||
assert_equal [{}], Psych.load_stream(s)
|
||||
assert_equal({}, Psych.parse(s).transform)
|
||||
assert_equal [{}], Psych.parse_stream(s).transform
|
||||
assert_equal({}, Psych.safe_load(s))
|
||||
end
|
||||
|
||||
def test_thousand
|
||||
s = "- 1000\n- +1000\n- 1_000"
|
||||
assert_equal [1000, 1000, 1000], Psych.load(s)
|
||||
assert_equal [[1000, 1000, 1000]], Psych.load_stream(s)
|
||||
assert_equal [1000, 1000, 1000], Psych.parse(s).transform
|
||||
assert_equal [[1000, 1000, 1000]], Psych.parse_stream(s).transform
|
||||
assert_equal [1000, 1000, 1000], Psych.safe_load(s)
|
||||
end
|
||||
|
||||
def test_8
|
||||
s = "[8, 08, 0o10, 010]"
|
||||
assert_equal [8, "08", "0o10", 8], Psych.load(s)
|
||||
assert_equal [[8, "08", "0o10", 8]], Psych.load_stream(s)
|
||||
assert_equal [8, "08", "0o10", 8], Psych.parse(s).transform
|
||||
assert_equal [[8, "08", "0o10", 8]], Psych.parse_stream(s).transform
|
||||
assert_equal [8, "08", "0o10", 8], Psych.safe_load(s)
|
||||
end
|
||||
|
||||
def test_null
|
||||
s = "null"
|
||||
assert_equal nil, Psych.load(s)
|
||||
assert_equal [nil], Psych.load_stream(s)
|
||||
assert_equal nil, Psych.parse(s).transform
|
||||
assert_equal [nil], Psych.parse_stream(s).transform
|
||||
assert_equal nil, Psych.safe_load(s)
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def special_case_cycle(object)
|
||||
%w[load load_stream parse parse_stream safe_load].map do |m|
|
||||
Psych.public_send(m, object)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
Loading…
Reference in a new issue