Class: Packer::DataObject

Inherits:
Object
  • Object
show all
Defined in:
lib/packer/dataobject.rb

Direct Known Subclasses

Builder, Config, PostProcessor, Provisioner

Defined Under Namespace

Classes: DataValidationError, ExclusiveKeyError

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ DataObject

Returns a new instance of DataObject.



8
9
10
11
12
 
# File 'lib/packer/dataobject.rb', line 8

def initialize
  self.data = {}
  self.required = []
  self.key_dependencies = {}
end

Instance Attribute Details

#data ⇒ Object

Returns the value of attribute data.



4
5
6
 
# File 'lib/packer/dataobject.rb', line 4

def data
  @data
end

#key_dependencies ⇒ Object

Returns the value of attribute key_dependencies.



6
7
8
 
# File 'lib/packer/dataobject.rb', line 6

def key_dependencies
  @key_dependencies
end

#required ⇒ Object

Returns the value of attribute required.



5
6
7
 
# File 'lib/packer/dataobject.rb', line 5

def required
  @required
end

Instance Method Details

#__add_array_of_array_of_strings(key, values, exclusives = []) ⇒ Object

Raises:

  • (TypeError) 


82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/packer/dataobject.rb', line 82

def __add_array_of_array_of_strings(key, values, exclusives = [])
  self.__exclusive_key_error(key, exclusives)
  raise TypeError.new() unless Array.try_convert(values)

  self.data[key.to_s] = []
  values.each do |v|
    raise TypeError.new() unless Array.try_convert(v)

    self.data[key.to_s].push(v.to_ary.map(&:to_s))
  end
end

#__add_array_of_hashes(key, values, exclusives = []) ⇒ Object

Raises:

  • (TypeError) 


94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/packer/dataobject.rb', line 94

def __add_array_of_hashes(key, values, exclusives = [])
  self.__exclusive_key_error(key, exclusives)
  raise TypeError.new() unless Array.try_convert(values)

  self.data[key.to_s] = []
  values.each do |v|
    raise TypeError.new() unless v.is_a?(Hash)

    self.data[key.to_s].push({})
    v.keys.each do |k|
      self.data[key.to_s][-1][k] = v[k].to_s
    end
  end
end

#__add_array_of_ints(key, values, exclusives = []) ⇒ Object

Raises:

  • (TypeError) 


109
110
111
112
113
114
 
# File 'lib/packer/dataobject.rb', line 109

def __add_array_of_ints(key, values, exclusives = [])
  self.__exclusive_key_error(key, exclusives)
  raise TypeError.new() unless Array.try_convert(values)

  self.data[key.to_s] = values.to_ary.map(&:to_i)
end

#__add_array_of_strings(key, values, exclusives = []) ⇒ Object

Raises:

  • (TypeError) 


75
76
77
78
79
80
 
# File 'lib/packer/dataobject.rb', line 75

def __add_array_of_strings(key, values, exclusives = [])
  self.__exclusive_key_error(key, exclusives)
  raise TypeError.new() unless Array.try_convert(values)

  self.data[key.to_s] = values.to_ary.map(&:to_s)
end

#__add_boolean(key, bool, exclusives = []) ⇒ Object 



127
128
129
130
 
# File 'lib/packer/dataobject.rb', line 127

def __add_boolean(key, bool, exclusives = [])
  self.__exclusive_key_error(key, exclusives)
  self.data[key.to_s] = bool ? true : false
end

#__add_hash(key, data, exclusives = []) ⇒ Object

Raises:

  • (TypeError) 


132
133
134
135
136
137
138
139
140
 
# File 'lib/packer/dataobject.rb', line 132

def __add_hash(key, data, exclusives = [])
  self.__exclusive_key_error(key, exclusives)
  raise TypeError.new() unless data.is_a?(Hash)

  self.data[key.to_s] = {}
  data.keys.each do |k|
    self.data[key.to_s][k] = data[k].to_s
  end
end

#__add_integer(key, data, exclusives = []) ⇒ Object 



121
122
123
124
 
# File 'lib/packer/dataobject.rb', line 121

def __add_integer(key, data, exclusives = [])
  self.__exclusive_key_error(key, exclusives)
  self.data[key.to_s] = data.to_i
end

#__add_json(key, data, exclusives = []) ⇒ Object

Raises:

  • (TypeError) 


143
144
145
146
147
148
149
150
151
 
# File 'lib/packer/dataobject.rb', line 143

def __add_json(key, data, exclusives = [])
  self.__exclusive_key_error(key, exclusives)
  raise TypeError.new() unless data.is_a?(Hash)

  self.data[key.to_s] = {}
  data.keys.each do |k|
    self.data[key.to_s][k] = data[k]
  end
end

#__add_string(key, data, exclusives = []) ⇒ Object 



116
117
118
119
 
# File 'lib/packer/dataobject.rb', line 116

def __add_string(key, data, exclusives = [])
  self.__exclusive_key_error(key, exclusives)
  self.data[key.to_s] = data.to_s
end

#__exclusive_key_error(key, exclusives) ⇒ Object 



66
67
68
69
70
71
72
73
 
# File 'lib/packer/dataobject.rb', line 66

def __exclusive_key_error(key, exclusives)
  exclusives.each do |e|
    if self.data.key? e
      raise ExclusiveKeyError.new("Only one of #{exclusives} can be used at a time")
    end
  end
  true
end

#add_key_dependencies(key_deps) ⇒ Object 



55
56
57
 
# File 'lib/packer/dataobject.rb', line 55

def add_key_dependencies(key_deps)
  self.key_dependencies.merge!(key_deps)
end

#add_required(*keys) ⇒ Object 



49
50
51
52
53
 
# File 'lib/packer/dataobject.rb', line 49

def add_required(*keys)
  keys.each do |k|
    self.required.push(k)
  end
end

#deep_copy ⇒ Object 



59
60
61
 
# File 'lib/packer/dataobject.rb', line 59

def deep_copy
  Marshal.load(Marshal.dump(self.data))
end

#validate ⇒ Object 



17
18
19
20
21
22
23
 
# File 'lib/packer/dataobject.rb', line 17

def validate
  validate_required
  validate_key_dependencies

  # TODO(ianc) Also validate the data with the packer command?
  true
end

#validate_key_dependencies ⇒ Object 



40
41
42
43
44
45
46
47
 
# File 'lib/packer/dataobject.rb', line 40

def validate_key_dependencies
  self.data.keys.each do |data_key|
    next unless self.key_dependencies.key? data_key
    unless (self.key_dependencies[data_key] - self.data.keys).empty?
      raise DataValidationError.new("Key #{data_key} requires that keys be defined: #{self.key_dependencies[data_key]}")
    end
  end
end

#validate_required ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/packer/dataobject.rb', line 25

def validate_required
  self.required.each do |r|
    if (r.is_a? Array) && !r.empty?
      if (r.length - (r - self.data.keys).length).zero?
        raise DataValidationError.new("Missing one required setting from the set #{r}")
      end
      if r.length - (r - self.data.keys).length > 1
        raise DataValidationError.new("Found more than one exclusive setting in data from set #{r}")
      end
    elsif ! self.data.key? r
      raise DataValidationError.new("Missing required setting #{r}")
    end
  end
end