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 ⇒ Resolver

Returns a new instance of Resolver.



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

def initialize
  @whitelist            = SafeYAML::OPTIONS[:whitelisted_tags] || []
  @initializers         = SafeYAML::OPTIONS[:custom_initializers] || {}
  @raise_on_unknown_tag = SafeYAML::OPTIONS[:raise_on_unknown_tag]
end

Instance Method Details

#get_and_check_node_tag(node) ⇒ Object 



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

def get_and_check_node_tag(node)
  tag = self.get_node_tag(node)
  if !!tag && @raise_on_unknown_tag && !tag_is_whitelisted?(tag)
    raise "Unknown YAML tag '#{tag}'"
  end
  tag
end

#resolve_map(node) ⇒ Object 



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

def resolve_map(node)
  tag = get_and_check_node_tag(node)
  return self.native_resolve(node) if tag_is_whitelisted?(tag)

  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 



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

def resolve_node(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 



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

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

#resolve_seq(node) ⇒ Object 



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

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) 


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

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