1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
# frozen_string_literal: true
require_relative '../../puppet/parameter'
# This specialized {Puppet::Parameter} handles validation and munging of paths.
# By default, a single path is accepted, and by calling {accept_arrays} it is possible to
# allow an array of paths.
#
class Puppet::Parameter::Path < Puppet::Parameter
# Specifies whether multiple paths are accepted or not.
# @dsl type
#
def self.accept_arrays(bool = true)
@accept_arrays = !!bool
end
def self.arrays?
@accept_arrays
end
# Performs validation of the given paths.
# If the concrete parameter defines a validation method, it may call this method to perform
# path validation.
# @raise [Puppet::Error] if this property is configured for single paths and an array is given
# @raise [Puppet::Error] if a path is not an absolute path
# @return [Array<String>] the given paths
#
def validate_path(paths)
if paths.is_a?(Array) and !self.class.arrays? then
fail _("%{name} only accepts a single path, not an array of paths") % { name: name }
end
fail(_("%{name} must be a fully qualified path") % { name: name }) unless Array(paths).all? { |path| absolute_path?(path) }
paths
end
# This is the default implementation of the `validate` method.
# It will be overridden if the validate option is used when defining the parameter.
# @return [void]
#
def unsafe_validate(paths)
validate_path(paths)
end
# This is the default implementation of `munge`.
# If the concrete parameter defines a `munge` method, this default implementation will be overridden.
# This default implementation does not perform any munging, it just checks the one/many paths
# constraints. A derived implementation can perform this check as:
# `paths.is_a?(Array) and ! self.class.arrays?` and raise a {Puppet::Error}.
# @param paths [String, Array<String>] one of multiple paths
# @return [String, Array<String>] the given paths
# @raise [Puppet::Error] if the given paths does not comply with the on/many paths rule.
def unsafe_munge(paths)
if paths.is_a?(Array) and !self.class.arrays? then
fail _("%{name} only accepts a single path, not an array of paths") % { name: name }
end
paths
end
end
|
