Module: Hocon::Impl::AbstractConfigValue
Overview
Trying very hard to avoid a parent reference in config values; when you have a tree like this, the availability of parent() tends to result in a lot of improperly-factored and non-modular code. Please don’t add parent().
Defined Under Namespace
Modules: NoExceptionsModifier
Classes: NotPossibleToResolve
Constant Summary
collapse
- ConfigImplUtil =
Hocon::Impl::ConfigImplUtil
- ConfigBugOrBrokenError =
Hocon::ConfigError::ConfigBugOrBrokenError
- ResolveStatus =
Hocon::Impl::ResolveStatus
Instance Attribute Summary collapse
Class Method Summary
collapse
Instance Method Summary
collapse
-
#==(other) ⇒ Object
-
#at_key(key) ⇒ Object
-
#at_key_with_origin(origin, key) ⇒ Object
Renamed this to be consistent with the other at_key* overloaded methods.
-
#at_path(path_expression) ⇒ Object
-
#at_path_with_origin(origin, path) ⇒ Object
In java this is an overloaded version of atPath.
-
#can_equal(other) ⇒ Object
-
#construct_delayed_merge(origin, stack) ⇒ Object
-
#delay_merge(stack, fallback) ⇒ Object
-
#hash ⇒ Object
-
#ignores_fallbacks? ⇒ Boolean
this is virtualized rather than a field because only some subclasses really need to store the boolean, and they may be able to pack it with another boolean to save space.
-
#initialize(origin) ⇒ Object
-
#inspect ⇒ Object
-
#merged_stack_with_non_object(stack, fallback) ⇒ Object
-
#merged_stack_with_object(stack, fallback) ⇒ Object
-
#merged_stack_with_the_unmergeable(stack, fallback) ⇒ Object
-
#merged_with_non_object(fallback) ⇒ Object
-
#merged_with_object(fallback) ⇒ Object
-
#merged_with_the_unmergeable(fallback) ⇒ Object
-
#new_copy(origin) ⇒ Object
-
#relativized(prefix) ⇒ Object
This is used when including one file in another; the included file is relativized to the path it’s included into in the parent file.
-
#render(options = Hocon::ConfigRenderOptions.defaults) ⇒ Object
-
#render_to_sb(sb, indent, at_root, at_key, options) ⇒ Object
-
#render_value_to_sb(sb, indent, at_root, options) ⇒ Object
to be overridden by subclasses.
-
#require_not_ignoring_fallbacks ⇒ Object
the withFallback() implementation is supposed to avoid calling mergedWith* if we’re ignoring fallbacks.
-
#resolve_status ⇒ Object
-
#resolve_substitutions(context, source) ⇒ Object
Called only by ResolveContext.resolve.
-
#to_fallback_value ⇒ Object
-
#to_s ⇒ Object
-
#transform_to_string ⇒ Object
toString() is a debugging-oriented string but this is defined to create a string that would parse back to the value in JSON.
-
#with_fallback(mergeable) ⇒ Object
-
#with_fallbacks_ignored ⇒ Object
-
#with_origin(origin) ⇒ Object
#unwrapped, #value_type
Instance Attribute Details
#origin ⇒ Object
Returns the value of attribute origin.
30
31
32
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 30
def origin
@origin
end
|
Class Method Details
.has_descendant_in_list?(list, descendant) ⇒ Boolean
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 89
def self.has_descendant_in_list?(list, descendant)
list.each do |v|
if v.equal?(descendant)
return true
end
end
list.each do |v|
if v.is_a?(Hocon::Impl::Container) && v.has_descendant?(descendant)
return true
end
end
false
end
|
.indent(sb, indent_size, options) ⇒ Object
294
295
296
297
298
299
300
301
302
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 294
def self.indent(sb, indent_size, options)
if options.formatted?
remaining = indent_size
while remaining > 0
sb << " "
remaining -= 1
end
end
end
|
.replace_child_in_list(list, child, replacement) ⇒ Object
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 66
def self.replace_child_in_list(list, child, replacement)
i = 0
while (i < list.size) && (! list[i].equal?(child))
i += 1
end
if (i == list.size)
raise ConfigBugOrBrokenError, "tried to replace #{child} which is not in #{list}"
end
new_stack = list.clone
if ! replacement.nil?
new_stack[i] = replacement
else
new_stack.delete(i)
end
if new_stack.empty?
nil
else
new_stack
end
end
|
Instance Method Details
#==(other) ⇒ Object
263
264
265
266
267
268
269
270
271
272
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 263
def ==(other)
if other.is_a?(Hocon::Impl::AbstractConfigValue)
can_equal(other) &&
value_type == other.value_type &&
ConfigImplUtil.equals_handling_nil?(unwrapped, other.unwrapped)
else
false
end
end
|
#at_key_with_origin(origin, key) ⇒ Object
Renamed this to be consistent with the other at_key* overloaded methods
#at_path(path_expression) ⇒ Object
#at_path_with_origin(origin, path) ⇒ Object
In java this is an overloaded version of atPath
370
371
372
373
374
375
376
377
378
379
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 370
def at_path_with_origin(origin, path)
parent = path.parent
result = at_key_with_origin(origin, path.last)
while not parent.nil? do
key = parent.last
result = result.at_key_with_origin(origin, key)
parent = parent.parent
end
result
end
|
#can_equal(other) ⇒ Object
259
260
261
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 259
def can_equal(other)
other.is_a?(Hocon::Impl::AbstractConfigValue)
end
|
#construct_delayed_merge(origin, stack) ⇒ Object
161
162
163
164
165
166
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 161
def construct_delayed_merge(origin, stack)
require 'hocon/impl/config_delayed_merge'
Hocon::Impl::ConfigDelayedMerge.new(origin, stack)
end
|
#delay_merge(stack, fallback) ⇒ Object
180
181
182
183
184
185
186
187
188
189
190
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 180
def delay_merge(stack, fallback)
new_stack = stack.clone
new_stack << fallback
construct_delayed_merge(Hocon::Impl::AbstractConfigObject.merge_origins(new_stack), new_stack)
end
|
#hash ⇒ Object
274
275
276
277
278
279
280
281
282
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 274
def hash
unwrapped_value = unwrapped
if unwrapped_value.nil?
0
else
unwrapped_value.hash
end
end
|
#ignores_fallbacks? ⇒ Boolean
this is virtualized rather than a field because only some subclasses really need to store the boolean, and they may be able to pack it with another boolean to save space.
139
140
141
142
143
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 139
def ignores_fallbacks?
resolve_status == Hocon::Impl::ResolveStatus::RESOLVED
end
|
#initialize(origin) ⇒ Object
26
27
28
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 26
def initialize(origin)
@origin = origin
end
|
#inspect ⇒ Object
290
291
292
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 290
def inspect
to_s
end
|
#merged_stack_with_non_object(stack, fallback) ⇒ Object
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 204
def merged_stack_with_non_object(stack, fallback)
require_not_ignoring_fallbacks
if resolve_status == ResolveStatus::RESOLVED
with_fallbacks_ignored
else
delay_merge(stack, fallback)
end
end
|
#merged_stack_with_object(stack, fallback) ⇒ Object
192
193
194
195
196
197
198
199
200
201
202
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 192
def merged_stack_with_object(stack, fallback)
require_not_ignoring_fallbacks
if self.is_a?(Hocon::Impl::AbstractConfigObject)
raise ConfigBugOrBrokenError, "Objects must reimplement merged_with_object"
end
merged_stack_with_non_object(stack, fallback)
end
|
#merged_stack_with_the_unmergeable(stack, fallback) ⇒ Object
168
169
170
171
172
173
174
175
176
177
178
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 168
def merged_stack_with_the_unmergeable(stack, fallback)
require_not_ignoring_fallbacks
new_stack = stack.clone
new_stack.concat(fallback.unmerged_values)
construct_delayed_merge(Hocon::Impl::AbstractConfigObject.merge_origins(new_stack), new_stack)
end
|
#merged_with_non_object(fallback) ⇒ Object
229
230
231
232
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 229
def merged_with_non_object(fallback)
require_not_ignoring_fallbacks
merged_stack_with_non_object([self], fallback)
end
|
#merged_with_object(fallback) ⇒ Object
224
225
226
227
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 224
def merged_with_object(fallback)
require_not_ignoring_fallbacks
merged_stack_with_object([self], fallback)
end
|
#merged_with_the_unmergeable(fallback) ⇒ Object
219
220
221
222
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 219
def merged_with_the_unmergeable(fallback)
require_not_ignoring_fallbacks
merged_stack_with_the_unmergeable([self], fallback)
end
|
#new_copy(origin) ⇒ Object
132
133
134
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 132
def new_copy(origin)
raise ConfigBugOrBrokenError, "subclasses of AbstractConfigValue should provide their own implementation of `new_copy` (#{self.class})"
end
|
#relativized(prefix) ⇒ Object
This is used when including one file in another; the included file is relativized to the path it’s included into in the parent file. The point is that if you include a file at foo.bar in the parent, and the included file as a substitution $Hocon::Impl::AbstractConfigValue.aa.ba.b.c, the included substitution now needs to be $Hocon::Impl::AbstractConfigValue.foofoo.barfoo.bar.afoo.bar.a.bfoo.bar.a.b.c because we resolve substitutions globally only after parsing everything.
114
115
116
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 114
def relativized(prefix)
self
end
|
#render(options = Hocon::ConfigRenderOptions.defaults) ⇒ Object
341
342
343
344
345
346
347
348
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 341
def render(options = Hocon::ConfigRenderOptions.defaults)
sb = StringIO.new
render_to_sb(sb, 0, true, nil, options)
sb.string[0, sb.pos]
end
|
#render_to_sb(sb, indent, at_root, at_key, options) ⇒ Object
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 304
def render_to_sb(sb, indent, at_root, at_key, options)
if !at_key.nil?
rendered_key =
if options.json?
ConfigImplUtil.render_json_string(at_key)
else
ConfigImplUtil.render_string_unquoted_if_possible(at_key)
end
sb << rendered_key
if options.json?
if options.formatted?
sb << " : "
else
sb << ":"
end
else
if self.is_a?(Hocon::ConfigObject)
if options.formatted?
sb << ' '
end
else
sb << "="
end
end
end
render_value_to_sb(sb, indent, at_root, options)
end
|
#render_value_to_sb(sb, indent, at_root, options) ⇒ Object
to be overridden by subclasses
336
337
338
339
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 336
def render_value_to_sb(sb, indent, at_root, options)
u = unwrapped
sb << u.to_s
end
|
#require_not_ignoring_fallbacks ⇒ Object
the withFallback() implementation is supposed to avoid calling mergedWith* if we’re ignoring fallbacks.
155
156
157
158
159
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 155
def require_not_ignoring_fallbacks
if ignores_fallbacks?
raise ConfigBugOrBrokenError, "method should not have been called with ignoresFallbacks=true #{self.class.name}"
end
end
|
#resolve_substitutions(context, source) ⇒ Object
Called only by ResolveContext.resolve
58
59
60
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 58
def resolve_substitutions(context, source)
Hocon::Impl::ResolveResult.make(context, self)
end
|
#to_fallback_value ⇒ Object
128
129
130
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 128
def to_fallback_value
self
end
|
#to_s ⇒ Object
284
285
286
287
288
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 284
def to_s
sb = StringIO.new
render_to_sb(sb, 0, true, nil, Hocon::ConfigRenderOptions.concise)
"#{self.class.name.split('::').last}(#{sb.string})"
end
|
toString() is a debugging-oriented string but this is defined to create a string that would parse back to the value in JSON. It only works for primitive values (that would be a single which are auto-converted to strings when concatenating with other strings or by the DefaultTransformer.
355
356
357
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 355
def transform_to_string
nil
end
|
#with_fallback(mergeable) ⇒ Object
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 242
def with_fallback(mergeable)
if ignores_fallbacks?
self
else
other = mergeable.to_fallback_value
if other.is_a?(Hocon::Impl::Unmergeable)
merged_with_the_unmergeable(other)
elsif other.is_a?(Hocon::Impl::AbstractConfigObject)
merged_with_object(other)
else
merged_with_non_object(other)
end
end
end
|
#with_fallbacks_ignored ⇒ Object
145
146
147
148
149
150
151
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 145
def with_fallbacks_ignored
if ignores_fallbacks?
self
else
raise ConfigBugOrBrokenError, "value class doesn't implement forced fallback-ignoring #{self}"
end
end
|
#with_origin(origin) ⇒ Object
234
235
236
237
238
239
240
|
# File 'lib/hocon/impl/abstract_config_value.rb', line 234
def with_origin(origin)
if @origin.equal?(origin)
self
else
new_copy(origin)
end
end
|