Class: SafeYAML::Resolver

Inherits:
Object
  • Object
show all
Defined in:
lib/safe_yaml/resolver.rb

Direct Known Subclasses

PsychResolver, SyckResolver

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Resolver

Returns a new instance of Resolver.



3
4
5
6
7
8
 
# File 'lib/safe_yaml/resolver.rb', line 3

def initialize(options)
  @options              = SafeYAML::OPTIONS.merge(options || {})
  @whitelist            = @options[:whitelisted_tags] || []
  @initializers         = @options[:custom_initializers] || {}
  @raise_on_unknown_tag = @options[:raise_on_unknown_tag]
end

Instance Method Details

#get_and_check_node_tag(node) ⇒ Object 



62
63
64
65
66
 
# File 'lib/safe_yaml/resolver.rb', line 62

def get_and_check_node_tag(node)
  tag = self.get_node_tag(node)
  SafeYAML.tag_safety_check!(tag, @options)
  tag
end

#options ⇒ Object 



72
73
74
 
# File 'lib/safe_yaml/resolver.rb', line 72

def options
  @options
end

#resolve_map(node) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/safe_yaml/resolver.rb', line 30

def resolve_map(node)
  tag  = get_and_check_node_tag(node)
  hash = @initializers.include?(tag) ? @initializers[tag].call : {}
  map  = normalize_map(self.get_node_value(node))

  # Take the "<<" key nodes first, as these are meant to approximate a form of inheritance.
  inheritors = map.select { |key_node, value_node| resolve_node(key_node) == "<<" }
  inheritors.each do |key_node, value_node|
    merge_into_hash(hash, resolve_node(value_node))
  end

  # All that's left should be normal (non-"<<") nodes.
  (map - inheritors).each do |key_node, value_node|
    hash[resolve_node(key_node)] = resolve_node(value_node)
  end

  return hash
end

#resolve_node(node) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/safe_yaml/resolver.rb', line 10

def resolve_node(node)
  return node if !node
  return self.native_resolve(node) if tag_is_whitelisted?(self.get_node_tag(node))

  case self.get_node_type(node)
  when :root
    resolve_root(node)
  when :map
    resolve_map(node)
  when :seq
    resolve_seq(node)
  when :scalar
    resolve_scalar(node)
  when :alias
    resolve_alias(node)
  else
    raise "Don't know how to resolve this node: #{node.inspect}"
  end
end

#resolve_scalar(node) ⇒ Object 



58
59
60
 
# File 'lib/safe_yaml/resolver.rb', line 58

def resolve_scalar(node)
  Transform.to_proper_type(self.get_node_value(node), self.value_is_quoted?(node), get_and_check_node_tag(node), @options)
end

#resolve_seq(node) ⇒ Object 



49
50
51
52
53
54
55
56
 
# File 'lib/safe_yaml/resolver.rb', line 49

def resolve_seq(node)
  seq = self.get_node_value(node)

  tag = get_and_check_node_tag(node)
  arr = @initializers.include?(tag) ? @initializers[tag].call : []

  seq.inject(arr) { |array, node| array << resolve_node(node) }
end

#tag_is_whitelisted?(tag) ⇒ Boolean

Returns:

  • (Boolean) 


68
69
70
 
# File 'lib/safe_yaml/resolver.rb', line 68

def tag_is_whitelisted?(tag)
  @whitelist.include?(tag)
end