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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
class Chef
class Node
module Immutablize
def immutablize(value)
case value
when Hash
ImmutableMash.new(value)
when Array
ImmutableArray.new(value)
else
value
end
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
# A list of methods that mutate Array. Each of these is overridden to
# raise an error, making this instances of this class more or less
# immutable.
DISALLOWED_MUTATOR_METHODS = [
:<<,
:[]=,
:clear,
:collect!,
:compact!,
:default=,
:default_proc=,
:delete,
:delete_at,
:delete_if,
:fill,
:flatten!,
:insert,
:keep_if,
:map!,
:merge!,
:pop,
:push,
:update,
:reject!,
:reverse!,
:replace,
:select!,
:shift,
:slice!,
:sort!,
:sort_by!,
:uniq!,
:unshift
]
def initialize(array_data)
array_data.each do |value|
internal_push(immutablize(value))
end
end
# Redefine all of the methods that mutate a Hash to raise an error when called.
# This is the magic that makes this object "Immutable"
DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
# Ruby 1.8 blocks can't have block arguments, so we must use string eval:
class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
def #{mutator_method_name}(*args, &block)
raise Exceptions::ImmutableAttributeModification
end
METHOD_DEFN
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
a = Array.new
each do |v|
a <<
case v
when ImmutableArray
v.to_a
when ImmutableMash
v.to_hash
else
v
end
end
a
end
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
alias :internal_set :[]=
private :internal_set
DISALLOWED_MUTATOR_METHODS = [
:[]=,
:clear,
:collect!,
:default=,
:default_proc=,
:delete,
:delete_if,
:keep_if,
:map!,
:merge!,
:update,
:reject!,
:replace,
:select!,
:shift
]
def initialize(mash_data)
mash_data.each do |key, value|
internal_set(key, immutablize(value))
end
end
alias :attribute? :has_key?
# Redefine all of the methods that mutate a Hash to raise an error when called.
# This is the magic that makes this object "Immutable"
DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
# Ruby 1.8 blocks can't have block arguments, so we must use string eval:
class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
def #{mutator_method_name}(*args, &block)
raise Exceptions::ImmutableAttributeModification
end
METHOD_DEFN
end
def method_missing(symbol, *args)
if args.empty?
if key?(symbol)
self[symbol]
else
raise NoMethodError, "Undefined method or attribute `#{symbol}' on `node'"
end
# This will raise a ImmutableAttributeModification error:
elsif symbol.to_s =~ /=$/
key_to_set = symbol.to_s[/^(.+)=$/, 1]
self[key_to_set] = (args.length == 1 ? args[0] : args)
else
raise NoMethodError, "Undefined node attribute or method `#{symbol}' on `node'"
end
end
# Mash uses #convert_value to mashify values on input.
# Since we're handling this ourselves, override it to be a no-op
def convert_value(value)
value
end
# 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
Mash.new(self)
end
def to_hash
h = Hash.new
each_pair do |k, v|
h[k] =
case v
when ImmutableMash
v.to_hash
when ImmutableArray
v.to_a
else
v
end
end
h
end
end
end
end
|
