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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
#--
# Copyright:: Copyright 2012-2018, Chef Software Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
require "chef/node/common_api"
require "chef/node/mixin/state_tracking"
require "chef/node/mixin/immutablize_array"
require "chef/node/mixin/immutablize_hash"
class Chef
class Node
module Immutablize
# For elements like Fixnums, true, nil...
def safe_dup(e)
e.dup
rescue TypeError
e
end
def convert_value(value)
case value
when Hash
ImmutableMash.new(value, __root__, __node__, __precedence__)
when Array
ImmutableArray.new(value, __root__, __node__, __precedence__)
when ImmutableMash, ImmutableArray
value
else
safe_dup(value).freeze
end
end
def immutablize(value)
convert_value(value)
end
end
# == ImmutableArray
# ImmutableArray is used to implement Array collections when reading node
# attributes.
#
# ImmutableArray acts like an ordinary Array, except:
# * Methods that mutate the array are overridden to raise an error, making
# the collection more or less immutable.
# * Since this class stores values computed from a parent
# Chef::Node::Attribute's values, it overrides all reader methods to
# detect staleness and raise an error if accessed when stale.
class ImmutableArray < Array
include Immutablize
alias :internal_push :<<
private :internal_push
def initialize(array_data = [])
array_data.each do |value|
internal_push(immutablize(value))
end
end
# For elements like Fixnums, true, nil...
def safe_dup(e)
e.dup
rescue TypeError
e
end
def dup
Array.new(map { |e| safe_dup(e) })
end
def to_a
Array.new(map do |v|
case v
when ImmutableArray
v.to_a
when ImmutableMash
v.to_h
else
safe_dup(v)
end
end)
end
alias_method :to_array, :to_a
private
# needed for __path__
def convert_key(key)
key
end
prepend Chef::Node::Mixin::StateTracking
prepend Chef::Node::Mixin::ImmutablizeArray
end
# == ImmutableMash
# ImmutableMash implements Hash/Dict behavior for reading values from node
# attributes.
#
# ImmutableMash acts like a Mash (Hash that is indifferent to String or
# Symbol keys), with some important exceptions:
# * Methods that mutate state are overridden to raise an error instead.
# * Methods that read from the collection are overriden so that they check
# if the Chef::Node::Attribute has been modified since an instance of
# this class was generated. An error is raised if the object detects that
# it is stale.
# * Values can be accessed in attr_reader-like fashion via method_missing.
class ImmutableMash < Mash
include Immutablize
include CommonAPI
# this is for deep_merge usage, chef users must never touch this API
# @api private
def internal_set(key, value)
regular_writer(key, convert_value(value))
end
def initialize(mash_data = {})
mash_data.each do |key, value|
internal_set(key, value)
end
end
alias :attribute? :has_key?
# NOTE: #default and #default= are likely to be pretty confusing. For a
# regular ruby Hash, they control what value is returned for, e.g.,
# hash[:no_such_key] #=> hash.default
# Of course, 'default' has a specific meaning in Chef-land
def dup
h = Mash.new
each_pair do |k, v|
h[k] = safe_dup(v)
end
h
end
def to_h
h = Hash.new
each_pair do |k, v|
h[k] =
case v
when ImmutableMash
v.to_h
when ImmutableArray
v.to_a
else
safe_dup(v)
end
end
h
end
alias_method :to_hash, :to_h
# For elements like Fixnums, true, nil...
def safe_dup(e)
e.dup
rescue TypeError
e
end
prepend Chef::Node::Mixin::StateTracking
prepend Chef::Node::Mixin::ImmutablizeHash
end
end
end
|
