Module: Psych::Pure

Includes:
CommentExtensions::ToRubySingleton
Defined in:
lib/psych/pure.rb,
lib/psych/pure/version.rb

Overview

A YAML parser written in Ruby.

Defined Under Namespace

Modules: CommentExtensions Classes: Comment, Comments, Emitter, InternalException, LoadedArray, LoadedHash, LoadedObject, Parser, SafeEmitter, Source

Constant Summary collapse

VERSION = 
"0.3.1"

Class Method Summary collapse

Methods included from CommentExtensions::ToRubySingleton

#create

Class Method Details

.dump(o, io = nil, options = {}) ⇒ Object

Dump an object to a YAML string.



4931
4932
4933
4934
4935
4936
4937
4938
4939
4940
4941
 
# File 'lib/psych/pure.rb', line 4931

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

  real_io = io || StringIO.new
  emitter = Emitter.new(real_io, options)
  emitter.emit(o)
  io || real_io.string
end

.dump_stream(*objects) ⇒ Object

Dump a stream of objects to a YAML string.



4958
4959
4960
4961
4962
4963
 
# File 'lib/psych/pure.rb', line 4958

def self.dump_stream(*objects)
  real_io = io || StringIO.new
  emitter = Emitter.new(real_io, {})
  objects.each { |object| emitter.emit(object) }
  io || real_io.string
end

.load(yaml, permitted_classes: [Symbol], permitted_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false, freeze: false, strict_integer: false, parse_symbols: true, comments: false) ⇒ Object 



4867
4868
4869
4870
4871
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881
 
# File 'lib/psych/pure.rb', line 4867

def self.load(yaml, permitted_classes: [Symbol], permitted_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false, freeze: false, strict_integer: false, parse_symbols: true, comments: false)
  safe_load(
    yaml,
    permitted_classes: permitted_classes,
    permitted_symbols: permitted_symbols,
    aliases: aliases,
    filename: filename,
    fallback: fallback,
    symbolize_names: symbolize_names,
    freeze: freeze,
    strict_integer: strict_integer,
    parse_symbols: parse_symbols,
    comments: comments
  )
end

.load_file(filename, **kwargs) ⇒ Object 



4924
4925
4926
4927
4928
 
# File 'lib/psych/pure.rb', line 4924

def self.load_file(filename, **kwargs)
  File.open(filename, "r:bom|utf-8") do |f|
    self.load(f, filename: filename, **kwargs)
  end
end

.load_stream(yaml, filename: nil, fallback: [], comments: false, **kwargs) ⇒ Object 



4883
4884
4885
4886
4887
4888
4889
4890
4891
4892
4893
4894
4895
 
# File 'lib/psych/pure.rb', line 4883

def self.load_stream(yaml, filename: nil, fallback: [], comments: false, **kwargs)
  result =
    if block_given?
      parse_stream(yaml, filename: filename, comments: comments) do |node|
        yield node.to_ruby(**kwargs)
      end
    else
      parse_stream(yaml, filename: filename, comments: comments).children.map { |node| node.to_ruby(**kwargs) }
    end

  return fallback if result.is_a?(Array) && result.empty?
  result
end

.parse(yaml, filename: nil, comments: false) ⇒ Object 



4816
4817
4818
4819
4820
4821
4822
 
# File 'lib/psych/pure.rb', line 4816

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

  false
end

.parse_file(filename, fallback: false, comments: false) ⇒ Object 



4824
4825
4826
4827
4828
4829
4830
 
# File 'lib/psych/pure.rb', line 4824

def self.parse_file(filename, fallback: false, comments: false)
  result = File.open(filename, "r:bom|utf-8") do |f|
    parse(f, filename: filename, comments: comments)
  end

  result || fallback
end

.parse_stream(yaml, filename: nil, comments: false, &block) ⇒ Object

Parse a YAML stream and return the root node.



4833
4834
4835
4836
4837
4838
4839
4840
4841
4842
 
# File 'lib/psych/pure.rb', line 4833

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

.parser ⇒ Object

Create a new default parser.



4812
4813
4814
 
# File 'lib/psych/pure.rb', line 4812

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

.safe_dump(o, io = nil, options = {}) ⇒ Object

Dump an object to a YAML string, with restricted classes, symbols, and aliases.



4945
4946
4947
4948
4949
4950
4951
4952
4953
4954
4955
 
# File 'lib/psych/pure.rb', line 4945

def self.safe_dump(o, io = nil, options = {})
  if Hash === io
    options = io
    io = nil
  end

  real_io = io || StringIO.new
  emitter = SafeEmitter.new(real_io, options)
  emitter.emit(o)
  io || real_io.string
end

.safe_load(yaml, permitted_classes: [], permitted_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false, freeze: false, strict_integer: false, parse_symbols: true, comments: false) ⇒ Object 



4851
4852
4853
4854
4855
4856
4857
4858
4859
4860
4861
4862
4863
4864
4865
 
# File 'lib/psych/pure.rb', line 4851

def self.safe_load(yaml, permitted_classes: [], permitted_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false, freeze: false, strict_integer: false, parse_symbols: true, comments: false)
  result = parse(yaml, filename: filename, comments: comments)
  return fallback unless result

  class_loader = ClassLoader::Restricted.new(permitted_classes.map(&:to_s), permitted_symbols.map(&:to_s))
  scanner = ScalarScanner.new(class_loader, strict_integer: strict_integer, parse_symbols: parse_symbols)
  visitor =
    if aliases
      Visitors::ToRuby.new(scanner, class_loader, symbolize_names: symbolize_names, freeze: freeze, comments: comments)
    else
      Visitors::NoAliasRuby.new(scanner, class_loader, symbolize_names: symbolize_names, freeze: freeze, comments: comments)
    end

  visitor.accept(result)
end

.safe_load_file(filename, **kwargs) ⇒ Object 



4918
4919
4920
4921
4922
 
# File 'lib/psych/pure.rb', line 4918

def self.safe_load_file(filename, **kwargs)
  File.open(filename, "r:bom|utf-8") do |f|
    self.safe_load(f, filename: filename, **kwargs)
  end
end

.safe_load_stream(yaml, filename: nil, permitted_classes: [], aliases: false, comments: false) ⇒ Object 



4897
4898
4899
4900
4901
4902
4903
4904
4905
4906
4907
4908
4909
4910
 
# File 'lib/psych/pure.rb', line 4897

def self.safe_load_stream(yaml, filename: nil, permitted_classes: [], aliases: false, comments: false)
  documents = parse_stream(yaml, filename: filename).children.map do |child|
    stream = Psych::Nodes::Stream.new
    stream.children << child
    safe_load(stream.to_yaml, permitted_classes: permitted_classes, aliases: aliases, comments: comments)
  end

  if block_given?
    documents.each { |doc| yield doc }
    nil
  else
    documents
  end
end

.unsafe_load(yaml, filename: nil, fallback: false, symbolize_names: false, freeze: false, strict_integer: false, parse_symbols: true, comments: false) ⇒ Object 



4844
4845
4846
4847
4848
4849
 
# File 'lib/psych/pure.rb', line 4844

def self.unsafe_load(yaml, filename: nil, fallback: false, symbolize_names: false, freeze: false, strict_integer: false, parse_symbols: true, comments: false)
  result = parse(yaml, filename: filename, comments: comments)
  return fallback unless result

  result.to_ruby(symbolize_names: symbolize_names, freeze: freeze, strict_integer: strict_integer, parse_symbols: parse_symbols, comments: comments)
end

.unsafe_load_file(filename, **kwargs) ⇒ Object 



4912
4913
4914
4915
4916
 
# File 'lib/psych/pure.rb', line 4912

def self.unsafe_load_file(filename, **kwargs)
  File.open(filename, "r:bom|utf-8") do |f|
    self.unsafe_load(f, filename: filename, **kwargs)
  end
end