Module: Facter::Util::Values

Included in:
Confine
Defined in:
lib/facter/util/values.rb

Overview

A util module for facter containing helper methods

Defined Under Namespace

Classes: DeepFreezeError, DeepMergeError

Class Method Summary collapse

Class Method Details

.convert(value) ⇒ Object 



73
74
75
76
77
 
# File 'lib/facter/util/values.rb', line 73

def convert(value)
  value = value.to_s if value.is_a?(Symbol)
  value = value.downcase if value.is_a?(String)
  value
end

.deep_freeze(value) ⇒ void

This method returns an undefined value.

Duplicate and deeply freeze a given data structure

Parameters:

  • value (Object) —

    The structure to freeze



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/facter/util/values.rb', line 13

def deep_freeze(value)
  case value
  when Numeric, Symbol, TrueClass, FalseClass, NilClass
    # These are immutable values, we can safely ignore them
    value
  when String
    value.dup.freeze
  when Array
    value.map do |entry|
      deep_freeze(entry)
    end.freeze
  when Hash
    value.inject({}) do |hash, (key, value)|
      hash[deep_freeze(key)] = deep_freeze(value)
      hash
    end.freeze
  else
    raise DeepFreezeError, "Cannot deep freeze #{value}:#{value.class}"
  end
end

.deep_merge(left, right, path = [], &block) ⇒ Object

Perform a deep merge of two nested data structures.

Parameters:

  • left (Object)
  • right (Object)
  • path (Array<String>) (defaults to: []) —

    The traversal path followed when merging nested hashes

Returns:

  • (Object) —

    The merged data structure.



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/facter/util/values.rb', line 43

def deep_merge(left, right, path = [], &block)
  ret = nil

  if left.is_a? Hash and right.is_a? Hash
    ret = left.merge(right) do |key, left_val, right_val|
      path.push(key)
      merged = deep_merge(left_val, right_val, path)
      path.pop
      merged
    end
  elsif left.is_a? Array and right.is_a? Array
    ret = left.dup.concat(right)
  elsif right.nil?
    ret = left
  elsif left.nil?
    ret = right
  elsif left.nil? and right.nil?
    ret = nil
  else
    msg = "Cannot merge #{left.inspect}:#{left.class} and #{right.inspect}:#{right.class}"
    if not path.empty?
      msg << " at root"
      msg << path.map { |part| "[#{part.inspect}]" }.join
    end
    raise DeepMergeError, msg
  end

  ret
end