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
|
#--
# Copyright:: Copyright 2012-2017, 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
def immutablize(value)
case value
when Hash
ImmutableMash.new(value, __root__, __node__, __precedence__)
when Array
ImmutableArray.new(value, __root__, __node__, __precedence__)
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
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
# for consistency's sake -- integers 'converted' to integers
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
alias :internal_set :[]=
private :internal_set
def initialize(mash_data = {})
mash_data.each do |key, value|
internal_set(key, immutablize(value))
end
end
def public_method_that_only_deep_merge_should_use(key, value)
internal_set(key, immutablize(value))
end
alias :attribute? :has_key?
# Mash uses #convert_value to mashify values on input.
# Since we're handling this ourselves, override it to be a no-op
#
# FIXME? this seems wrong to do and i think is responsible for
# #dup needing to be more complicated than Mash.new(self)?
#
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
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
|