# frozen_string_literal: true
org.jruby.ext.psych.PsychLibrary.new.load(JRuby.runtime, false)
require "#{RUBY_VERSION[/\d+\.\d+/]}/psych.so"
require 'psych/streaming'
require 'psych/tree_builder'
require 'psych/json/tree_builder'
require 'psych/json/stream'
require 'psych/handlers/document_stream'
require 'psych/class_loader'
# Psych is a YAML parser and emitter.
# Psych leverages libyaml [Home page: http://pyyaml.org/wiki/LibYAML]
# or [HG repo: https://bitbucket.org/xi/libyaml] for its YAML parsing
# and emitting capabilities. In addition to wrapping libyaml, Psych also
# knows how to serialize and de-serialize most Ruby objects to and from
# = I NEED TO PARSE OR EMIT YAML RIGHT NOW!
# Psych.load("--- foo") # => "foo"
# Psych.dump("foo") # => "--- foo\n...\n"
# { :a => 'b'}.to_yaml # => "---\n:a: b\n"
# Got more time on your hands? Keep on reading!
# Psych provides a range of interfaces for parsing a YAML document ranging from
# low level to high level, depending on your parsing needs. At the lowest
# level, is an event based parser. Mid level is access to the raw YAML AST,
# and at the highest level is the ability to unmarshal YAML to Ruby objects.
# Psych provides a range of interfaces ranging from low to high level for
# producing YAML documents. Very similar to the YAML parsing interfaces, Psych
# provides at the lowest level, an event based system, mid-level is building
# a YAML AST, and the highest level is converting a Ruby object straight to
# The high level YAML parser provided by Psych simply takes YAML as input and
# returns a Ruby data structure. For information on using the high level parser
# ==== Reading from a string
# Psych.load("--- a") # => 'a'
# Psych.load("---\n - a\n - b") # => ['a', 'b']
# ==== Reading from a file
# Psych.load_file("database.yml")
# ==== Exception handling
# # The second argument changes only the exception contents
# Psych.parse("--- `", "file.txt")
# rescue Psych::SyntaxError => ex
# ex.file # => 'file.txt'
# ex.message # => "(file.txt): found character that cannot start any token"
# The high level emitter has the easiest interface. Psych simply takes a Ruby
# data structure and converts it to a YAML document. See Psych.dump for more
# information on dumping a Ruby data structure.
# ==== Writing to a string
# # Dump an array, get back a YAML string
# Psych.dump(['a', 'b']) # => "---\n- a\n- b\n"
# # Dump an array to an IO object
# Psych.dump(['a', 'b'], StringIO.new) # => #<StringIO:0x000001009d0890>
# # Dump an array with indentation set
# Psych.dump(['a', ['b']], :indentation => 3) # => "---\n- a\n- - b\n"
# # Dump an array to an IO with indentation set
# Psych.dump(['a', ['b']], StringIO.new, :indentation => 3)
# Currently there is no direct API for dumping Ruby structure to file:
# File.open('database.yml', 'w') do |file|
# file.write(Psych.dump(['a', 'b']))
# Psych provides access to an AST produced from parsing a YAML document. This
# tree is built using the Psych::Parser and Psych::TreeBuilder. The AST can
# be examined and manipulated freely. Please see Psych::parse_stream,
# Psych::Nodes, and Psych::Nodes::Node for more information on dealing with
# ==== Reading from a string
# # Returns Psych::Nodes::Stream
# Psych.parse_stream("---\n - a\n - b")
# # Returns Psych::Nodes::Document
# Psych.parse("---\n - a\n - b")
# ==== Reading from a file
# # Returns Psych::Nodes::Stream
# Psych.parse_stream(File.read('database.yml'))
# # Returns Psych::Nodes::Document
# Psych.parse_file('database.yml')
# ==== Exception handling
# # The second argument changes only the exception contents
# Psych.parse("--- `", "file.txt")
# rescue Psych::SyntaxError => ex
# ex.file # => 'file.txt'
# ex.message # => "(file.txt): found character that cannot start any token"
# At the mid level is building an AST. This AST is exactly the same as the AST
# used when parsing a YAML document. Users can build an AST by hand and the
# AST knows how to emit itself as a YAML document. See Psych::Nodes,
# Psych::Nodes::Node, and Psych::TreeBuilder for more information on building
# ==== Writing to a string
# # We need Psych::Nodes::Stream (not Psych::Nodes::Document)
# stream = Psych.parse_stream("---\n - a\n - b")
# stream.to_yaml # => "---\n- a\n- b\n"
# # We need Psych::Nodes::Stream (not Psych::Nodes::Document)
# stream = Psych.parse_stream(File.read('database.yml'))
# File.open('database.yml', 'w') do |file|
# file.write(stream.to_yaml)
# The lowest level parser should be used when the YAML input is already known,
# and the developer does not want to pay the price of building an AST or
# automatic detection and conversion to Ruby objects. See Psych::Parser for
# more information on using the event based parser.
# ==== Reading to Psych::Nodes::Stream structure
# parser = Psych::Parser.new(TreeBuilder.new) # => #<Psych::Parser>
# parser = Psych.parser # it's an alias for the above
# parser.parse("---\n - a\n - b") # => #<Psych::Parser>
# parser.handler # => #<Psych::TreeBuilder>
# parser.handler.root # => #<Psych::Nodes::Stream>
# ==== Receiving an events stream
# recorder = Psych::Handlers::Recorder.new
# parser = Psych::Parser.new(recorder)
# parser.parse("---\n - a\n - b")
# recorder.events # => [list of [event, args] lists]
# # event is one of: Psych::Handler::EVENTS
# # args are the arguments passed to the event
# The lowest level emitter is an event based system. Events are sent to a
# Psych::Emitter object. That object knows how to convert the events to a YAML
# document. This interface should be used when document format is known in
# advance or speed is a concern. See Psych::Emitter for more information.
# ==== Writing to a Ruby structure
# Psych.parser.parse("--- a") # => #<Psych::Parser>
# parser.handler.first # => #<Psych::Nodes::Stream>
# parser.handler.first.to_ruby # => ["a"]
# parser.handler.root.first # => #<Psych::Nodes::Document>
# parser.handler.root.first.to_ruby # => "a"
# # You can instantiate an Emitter manually
# Psych::Visitors::ToRuby.new.accept(parser.handler.root.first)
# The version of libyaml Psych is using
LIBYAML_VERSION = Psych.libyaml_version.join '.'
FALLBACK = Struct.new :to_ruby # :nodoc:
# 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
# Raises a Psych::SyntaxError when a YAML syntax error is detected.
# Psych.load("--- a") # => 'a'
# Psych.load("---\n - a\n - b") # => ['a', 'b']
# Psych.load("--- `", "file.txt")
# rescue Psych::SyntaxError => ex
# ex.file # => 'file.txt'
# ex.message # => "(file.txt): found character that cannot start any token"
# When the optional +symbolize_names+ keyword argument is set to a
# true value, returns symbols for keys in Hash objects (default: strings).
# 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)
result = result.to_ruby if result
symbolize_names!(result) if symbolize_names
# Safely load the yaml string in +yaml+. By default, only the following
# classes are allowed to be deserialized:
# Recursive data structures are not allowed by default. Arbitrary classes
# can be allowed by adding those classes to the +whitelist+. They are
# additive. For example, to allow Date deserialization:
# Psych.safe_load(yaml, [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.
# Psych.safe_load yaml # => raises an exception
# Psych.safe_load yaml, [], [], 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.
# +filename+ will be used in the exception message if any exception is raised
# When the optional +symbolize_names+ keyword argument is set to a
# true value, returns symbols for keys in Hash objects (default: strings).
# 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)
class_loader = ClassLoader::Restricted.new(whitelist_classes.map(&:to_s),
whitelist_symbols.map(&:to_s))
scanner = ScalarScanner.new class_loader
visitor = Visitors::ToRuby.new scanner, class_loader
visitor = Visitors::NoAliasRuby.new scanner, class_loader
result = visitor.accept result
symbolize_names!(result) if symbolize_names
# Parse a YAML string in +yaml+. Returns the Psych::Nodes::Document.
# +filename+ is used in the exception message if a Psych::SyntaxError is
# Raises a Psych::SyntaxError when a YAML syntax error is detected.
# Psych.parse("---\n - a\n - b") # => #<Psych::Nodes::Document:0x00>
# Psych.parse("--- `", "file.txt")
# rescue Psych::SyntaxError => ex
# ex.file # => 'file.txt'
# ex.message # => "(file.txt): found character that cannot start any token"
# See Psych::Nodes for more information about YAML AST.
def self.parse yaml, filename = nil, fallback: false
parse_stream(yaml, filename) do |node|
# 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|
# Returns a default parser
Psych::Parser.new(TreeBuilder.new)
# Parse a YAML string in +yaml+. Returns the Psych::Nodes::Stream.
# This method can handle multiple YAML documents contained in +yaml+.
# +filename+ is used in the exception message if a Psych::SyntaxError is
# If a block is given, a Psych::Nodes::Document node will be yielded to the
# block as it's being parsed.
# Raises a Psych::SyntaxError when a YAML syntax error is detected.
# Psych.parse_stream("---\n - a\n - b") # => #<Psych::Nodes::Stream:0x00>
# Psych.parse_stream("--- a\n--- b") do |node|
# node # => #<Psych::Nodes::Document:0x00>
# Psych.parse_stream("--- `", "file.txt")
# rescue Psych::SyntaxError => ex
# ex.file # => 'file.txt'
# ex.message # => "(file.txt): found character that cannot start any token"
# See Psych::Nodes for more information about YAML AST.
def self.parse_stream yaml, filename = nil, &block
parser = Psych::Parser.new(Handlers::DocumentStream.new(&block))
parser.parse yaml, filename
parser.parse yaml, filename
# Psych.dump(o) -> string of yaml
# Psych.dump(o, options) -> string of yaml
# Psych.dump(o, io) -> io object passed in
# Psych.dump(o, io, options) -> io object passed in
# Dump Ruby object +o+ to a YAML string. Optional +options+ may be passed in
# to control the output format. If an IO object is passed in, the YAML will
# be dumped to that IO object.
# # Dump an array, get back a YAML string
# Psych.dump(['a', 'b']) # => "---\n- a\n- b\n"
# # Dump an array to an IO object
# Psych.dump(['a', 'b'], StringIO.new) # => #<StringIO:0x000001009d0890>
# # Dump an array with indentation set
# Psych.dump(['a', ['b']], :indentation => 3) # => "---\n- a\n- - b\n"
# # Dump an array to an IO with indentation set
# Psych.dump(['a', ['b']], StringIO.new, :indentation => 3)
def self.dump o, io = nil, options = {}
visitor = Psych::Visitors::YAMLTree.create options
visitor.tree.yaml io, options
# Dump a list of objects as separate documents to a document stream.
# Psych.dump_stream("foo\n ", {}) # => "--- ! \"foo\\n \"\n--- {}\n"
def self.dump_stream *objects
visitor = Psych::Visitors::YAMLTree.create({})
# Dump Ruby +object+ to a JSON string.
visitor = Psych::Visitors::JSONTree.create
# Load multiple documents given in +yaml+. Returns the parsed documents
# as a list. If a block is given, each document will be converted to Ruby
# and passed to the block during parsing
# Psych.load_stream("--- foo\n...\n--- bar\n...") # => ['foo', 'bar']
# Psych.load_stream("--- foo\n...\n--- bar\n...") do |ruby|
# list # => ['foo', 'bar']
def self.load_stream yaml, filename = nil
parse_stream(yaml, filename) do |node|
parse_stream(yaml, filename).children.map { |child| child.to_ruby }
# Load the document contained in +filename+. Returns the yaml contained in
# +filename+ as a Ruby object, or if the file is empty, it returns
# the specified default return value, which defaults to an empty Hash
def self.load_file filename, fallback: false
File.open(filename, 'r:bom|utf-8') { |f|
self.load f, filename, fallback: FALLBACK.new(fallback)
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
