module Psych - Documentation for Ruby 2.3.0 (original) (raw)

Overview ↑

Psych is a YAML parser and emitter. Psych leverages libyaml [Home page: pyyaml.org/wiki/LibYAML] or [HG repo: 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 the YAML format.

I NEED TO PARSE OR EMIT YAML RIGHT NOW¶ ↑

Psych.load("--- foo")

Psych.dump("foo")
{ :a => 'b'}.to_yaml

Got more time on your hands? Keep on reading!

YAML Parsing ↑

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.

YAML Emitting ↑

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 a YAML document.

High-level API ↑

Parsing ↑

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 see Psych.load

Reading from a string ↑

Psych.load("--- a")
Psych.load("---\n - a\n - b")

Reading from a file ↑

Psych.load_file("database.yml")

Exception handling ↑

begin

Psych.parse("--- `", "file.txt") rescue Psych::SyntaxError => ex ex.file
ex.message end

Emitting ↑

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 ↑

Psych.dump(['a', 'b'])

Psych.dump(['a', 'b'], StringIO.new)

Psych.dump(['a', ['b']], :indentation => 3)

Psych.dump(['a', ['b']], StringIO.new, :indentation => 3)

Writing to a file ↑

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'])) end

Mid-level API ↑

Parsing ↑

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 YAML syntax trees.

Reading from a string ↑

Psych.parse_stream("---\n - a\n - b")

Psych.parse("---\n - a\n - b")

Reading from a file ↑

Psych.parse_stream(File.read('database.yml'))

Psych.parse_file('database.yml')

Exception handling ↑

begin

Psych.parse("--- `", "file.txt") rescue Psych::SyntaxError => ex ex.file
ex.message end

Emitting ↑

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 a YAML AST.

Writing to a string ↑

stream = Psych.parse_stream("---\n - a\n - b")

stream.to_yaml

Writing to a file ↑

stream = Psych.parse_stream(File.read('database.yml'))

File.open('database.yml', 'w') do |file| file.write(stream.to_yaml) end

Low-level API ↑

Parsing ↑

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) parser = Psych.parser

parser.parse("---\n - a\n - b")
parser.handler
parser.handler.root

Receiving an events stream ↑

parser = Psych::Parser.new(Psych::Handlers::Recorder.new)

parser.parse("---\n - a\n - b") parser.events

Emitting ↑

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")

parser.handler.first
parser.handler.first.to_ruby

parser.handler.root.first
parser.handler.root.first.to_ruby

Psych::Visitors::ToRuby.new.accept(parser.handler.root.first)

Constants

DEFAULT_SNAKEYAML_VERSION

LIBYAML_VERSION

The version of libyaml Psych is using

VERSION

The version is Psych you're using

Public Class Methods

add_private_type(type_tag, &block) click to toggle source

def self.add_private_type type_tag, &block warn "#{caller[0]}: add_private_type is deprecated, use add_domain_type" if $VERBOSE domain = 'x-private' key = [domain, type_tag].join ':' @domain_types[key] = [key, block] end

add_ruby_type(type_tag, &block) click to toggle source

def self.add_ruby_type type_tag, &block warn "#{caller[0]}: add_ruby_type is deprecated, use add_domain_type" if $VERBOSE domain = 'ruby.yaml.org,2002' key = ['tag', domain, type_tag].join ':' @domain_types[key] = [key, block] end

detect_implicit(thing) click to toggle source

def self.detect_implicit thing warn "#{caller[0]}: detect_implicit is deprecated" if $VERBOSE return '' unless String === thing return 'null' if '' == thing ss = ScalarScanner.new(ClassLoader.new) ss.tokenize(thing).class.name.downcase end

dump(o) → string of yaml click to toggle source

dump(o, options) → string of yaml

dump(o, io) → io object passed in

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.

Example:

Psych.dump(['a', 'b'])

Psych.dump(['a', 'b'], StringIO.new)

Psych.dump(['a', ['b']], :indentation => 3)

Psych.dump(['a', ['b']], StringIO.new, :indentation => 3)

def self.dump o, io = nil, options = {} if Hash === io options = io io = nil end

visitor = Psych::Visitors::YAMLTree.create options visitor << o visitor.tree.yaml io, options end

dump_stream(*objects) click to toggle source

Dump a list of objects as separate documents to a document stream.

Example:

Psych.dump_stream("foo\n ", {})

def self.dump_stream *objects visitor = Psych::Visitors::YAMLTree.create({}) objects.each do |o| visitor << o end visitor.tree.yaml end

libyaml_version click to toggle source

Returns the version of libyaml being used

static VALUE libyaml_version(VALUE module) { int major, minor, patch; VALUE list[3];

yaml_get_version(&major, &minor, &patch);

list[0] = INT2NUM((long)major);
list[1] = INT2NUM((long)minor);
list[2] = INT2NUM((long)patch);

return rb_ary_new4((long)3, list);

}

load(yaml, filename = nil, fallback = false) click to toggle source

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.

Raises a Psych::SyntaxError when a YAML syntax error is detected.

Example:

Psych.load("--- a")
Psych.load("---\n - a\n - b")

begin Psych.load("--- `", "file.txt") rescue Psych::SyntaxError => ex ex.file
ex.message end

def self.load yaml, filename = nil, fallback = false result = parse(yaml, filename, fallback) result ? result.to_ruby : result end

load_documents(yaml, &block) click to toggle source

This method is deprecated, use Psych.load_stream instead.

def self.load_documents yaml, &block if $VERBOSE warn "#{caller[0]}: load_documents is deprecated, use load_stream" end list = load_stream yaml return list unless block_given? list.each(&block) end

load_file(filename, fallback = false) click to toggle source

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.new(fallback) } end

load_stream(yaml, filename = nil) { |to_ruby| ... } click to toggle source

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

Example:

Psych.load_stream("--- foo\n...\n--- bar\n...")

list = [] Psych.load_stream("--- foo\n...\n--- bar\n...") do |ruby| list << ruby end list

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 } end end

object_maker(klass, hash) click to toggle source

def self.object_maker klass, hash warn "#{caller[0]}: object_maker is deprecated" if $VERBOSE klass.allocate.tap do |obj| hash.each { |k,v| obj.instance_variable_set(:"@#{k}", v) } end end

parse(yaml, filename = nil, fallback = false) click to toggle source

Parse a YAML string in yaml. Returns the Psych::Nodes::Document. filename is used in the exception message if a Psych::SyntaxError is raised.

Raises a Psych::SyntaxError when a YAML syntax error is detected.

Example:

Psych.parse("---\n - a\n - b")

begin Psych.parse("--- `", "file.txt") rescue Psych::SyntaxError => ex ex.file
ex.message end

See Psych::Nodes for more information about YAML AST.

def self.parse yaml, filename = nil, fallback = false parse_stream(yaml, filename) do |node| return node end fallback end

parse_file(filename) click to toggle source

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 end end

parse_stream(yaml, filename = nil, &block) click to toggle source

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 raised.

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.

Example:

Psych.parse_stream("---\n - a\n - b")

Psych.parse_stream("--- a\n--- b") do |node| node end

begin Psych.parse_stream("--- `", "file.txt") rescue Psych::SyntaxError => ex ex.file
ex.message end

See Psych::Nodes for more information about YAML AST.

def self.parse_stream yaml, filename = nil, &block if block_given? parser = Psych::Parser.new(Handlers::DocumentStream.new(&block)) parser.parse yaml, filename else parser = self.parser parser.parse yaml, filename parser.handler.root end end

parser() click to toggle source

Returns a default parser

def self.parser Psych::Parser.new(TreeBuilder.new) end

read_type_class(type, reference) click to toggle source

def self.read_type_class type, reference warn "#{caller[0]}: read_type_class is deprecated" if $VERBOSE _, _, type, name = type.split ':', 4

reference = name.split('::').inject(reference) do |k,n| k.const_get(n.to_sym) end if name [type, reference] end

safe_load(yaml, whitelist_classes = [], whitelist_symbols = [], aliases = false, filename = nil) click to toggle source

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. For example:

x = [] x << x yaml = Psych.dump x Psych.safe_load yaml
Psych.safe_load yaml, [], [], true

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.

def self.safe_load yaml, whitelist_classes = [], whitelist_symbols = [], aliases = false, filename = nil result = parse(yaml, filename) return 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.accept result end

tagurize(thing) click to toggle source

def self.tagurize thing warn "#{caller[0]}: add_private_type is deprecated, use add_domain_type" if $VERBOSE return thing unless String === thing "tag:yaml.org,2002:#{thing}" end

to_json(object) click to toggle source

Dump Ruby object to a JSON string.

def self.to_json object visitor = Psych::Visitors::JSONTree.create visitor << object visitor.tree.yaml end