Class: Hocon::Impl::Parseable
- Inherits:
-
Object
- Object
- Hocon::Impl::Parseable
show all
- Includes:
- ConfigParseable
- Defined in:
- lib/hocon/impl/parseable.rb
Overview
Internal implementation detail, not ABI stable, do not touch. For use only by the com.typesafe.config package. The point of this class is to avoid “propagating” each overload on “thing which can be parsed” through multiple interfaces. Most interfaces can have just one overload that takes a Parseable. Also it’s used as an abstract “resource handle” in the ConfigIncluder interface.
Defined Under Namespace
Modules: Relativizer
Classes: ParseableFile, ParseableNotFound, ParseableResources, ParseableString
Constant Summary
collapse
- MAX_INCLUDE_DEPTH =
50
- @@parse_stack =
Changed this to a class variable because the upstream library seems to use it as a global way of keeping track of how many files have been included, to avoid cycles
[]
Class Method Summary
collapse
Instance Method Summary
collapse
-
#content_type ⇒ Object
-
#create_origin ⇒ Object
-
#custom_reader ⇒ Object
the general idea is that any work should be in here, not in the constructor, so that exceptions are thrown from the public parse() function and not from the creation of the Parseable.
-
#fixup_options(base_options) ⇒ Object
-
#guess_syntax ⇒ Object
-
#include_context ⇒ Object
-
#initialize ⇒ Parseable
constructor
A new instance of Parseable.
-
#options ⇒ Object
-
#origin ⇒ Object
-
#parse(base_options = nil) ⇒ Object
-
#parse_config_document ⇒ Object
-
#parse_document(base_options = nil) ⇒ Object
-
#parse_document_from_origin(origin, final_options) ⇒ Object
-
#parse_value(base_options = nil) ⇒ Object
-
#parse_value_from_origin(origin, final_options) ⇒ Object
-
#post_construct(base_options) ⇒ Object
-
#raw_parse_document(origin, final_options) ⇒ Object
-
#raw_parse_document_from_io(reader, origin, final_options) ⇒ Object
-
#raw_parse_value(origin, final_options) ⇒ Object
this is parseValue without post-processing the IOException or handling options.getAllowMissing().
-
#raw_parse_value_from_io(io, origin, final_options) ⇒ Object
-
#reader(options) ⇒ Object
-
#relative_to(filename) ⇒ Object
-
#to_s ⇒ Object
Constructor Details
Returns a new instance of Parseable.
45
46
47
|
# File 'lib/hocon/impl/parseable.rb', line 45
def initialize
end
|
Class Method Details
.force_parsed_to_object(value) ⇒ Object
.new_file(file_path, options) ⇒ Object
464
465
466
|
# File 'lib/hocon/impl/parseable.rb', line 464
def self.new_file(file_path, options)
ParseableFile.new(file_path, options)
end
|
.new_not_found(what_not_found, message, options) ⇒ Object
348
349
350
|
# File 'lib/hocon/impl/parseable.rb', line 348
def self.new_not_found(what_not_found, message, options)
ParseableNotFound.new(what_not_found, message, options)
end
|
.new_resources(resource, options) ⇒ Object
544
545
546
|
# File 'lib/hocon/impl/parseable.rb', line 544
def self.new_resources(resource, options)
ParseableResources.new(resource, options)
end
|
.new_string(string, options) ⇒ Object
390
391
392
|
# File 'lib/hocon/impl/parseable.rb', line 390
def self.new_string(string, options)
ParseableString.new(string, options)
end
|
.relative_to(file, filename) ⇒ Object
NOTE: skipping ‘relativeTo(URL, String)` because we’re not supporting URLs for now
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
|
# File 'lib/hocon/impl/parseable.rb', line 313
def self.relative_to(file, filename)
child = Pathname.new(filename)
file = Pathname.new(file)
if child.absolute?
nil
end
parent = file.parent
if parent.nil?
nil
else
File.join(parent, filename)
end
end
|
.syntax_from_extension(name) ⇒ Object
299
300
301
302
303
304
305
306
307
308
|
# File 'lib/hocon/impl/parseable.rb', line 299
def self.syntax_from_extension(name)
if name.end_with?(".json")
Hocon::ConfigSyntax::JSON
elsif name.end_with?(".conf")
Hocon::ConfigSyntax::CONF
else
nil
end
end
|
Instance Method Details
#content_type ⇒ Object
102
103
104
|
# File 'lib/hocon/impl/parseable.rb', line 102
def content_type
nil
end
|
#create_origin ⇒ Object
287
288
289
|
# File 'lib/hocon/impl/parseable.rb', line 287
def create_origin
raise Hocon::ConfigError::ConfigBugOrBrokenError, "subclasses of `Parseable` must implement `create_origin` (#{self.class})"
end
|
#custom_reader ⇒ Object
the general idea is that any work should be in here, not in the constructor, so that exceptions are thrown from the public parse() function and not from the creation of the Parseable. Essentially this is a lazy field. The parser should close the reader when it’s done with it. //# ALSO, IMPORTANT: if the file or URL is not found, this must throw. //# to support the “allow missing” feature.
84
85
86
|
# File 'lib/hocon/impl/parseable.rb', line 84
def custom_reader
raise Hocon::ConfigError::ConfigBugOrBrokenError, "subclasses of `Parseable` must implement `custom_reader` (#{self.class})"
end
|
#fixup_options(base_options) ⇒ Object
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
# File 'lib/hocon/impl/parseable.rb', line 49
def fixup_options(base_options)
syntax = base_options.syntax
if !syntax
syntax = guess_syntax
end
if !syntax
syntax = Hocon::ConfigSyntax::CONF
end
modified = base_options.set_syntax(syntax)
modified = modified.append_includer(Hocon::Impl::ConfigImpl.default_includer)
modified = modified.set_includer(Hocon::Impl::SimpleIncluder.make_full(modified.includer))
modified
end
|
#guess_syntax ⇒ Object
98
99
100
|
# File 'lib/hocon/impl/parseable.rb', line 98
def guess_syntax
nil
end
|
#include_context ⇒ Object
118
119
120
|
# File 'lib/hocon/impl/parseable.rb', line 118
def include_context
@include_context
end
|
#options ⇒ Object
291
292
293
|
# File 'lib/hocon/impl/parseable.rb', line 291
def options
@initial_options
end
|
#origin ⇒ Object
283
284
285
|
# File 'lib/hocon/impl/parseable.rb', line 283
def origin
@initial_origin
end
|
#parse(base_options = nil) ⇒ Object
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
# File 'lib/hocon/impl/parseable.rb', line 133
def parse(base_options = nil)
if (base_options.nil?)
base_options = options
end
stack = @@parse_stack
if stack.length >= MAX_INCLUDE_DEPTH
raise Hocon::ConfigError::ConfigParseError.new(@initial_origin,
"include statements nested more than #{MAX_INCLUDE_DEPTH} times, " +
"you probably have a cycle in your includes. Trace: #{stack}",
nil)
end
stack.unshift(self)
begin
self.class.force_parsed_to_object(parse_value(base_options))
ensure
stack.shift
end
end
|
#parse_config_document ⇒ Object
279
280
281
|
# File 'lib/hocon/impl/parseable.rb', line 279
def parse_config_document
parse_document(options)
end
|
#parse_document(base_options = nil) ⇒ Object
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
# File 'lib/hocon/impl/parseable.rb', line 189
def parse_document(base_options = nil)
if base_options.nil?
base_options = options
end
options = fixup_options(base_options)
origin = nil
if ! options.origin_description.nil?
origin = Hocon::Impl::SimpleConfigOrigin.new_simple(options.origin_description)
else
origin = @initial_origin
end
parse_document_from_origin(origin, options)
end
|
#parse_document_from_origin(origin, final_options) ⇒ Object
210
211
212
213
214
215
216
217
218
219
220
221
222
|
# File 'lib/hocon/impl/parseable.rb', line 210
def parse_document_from_origin(origin, final_options)
begin
raw_parse_document(origin, final_options)
rescue IOError => e
if final_options.allow_missing?
Hocon::Impl::SimpleConfigDocument.new(
Hocon::Impl::ConfigNodeObject.new([]), final_options)
else
self.class.trace("exception loading #{origin.description}: #{e.class}: #{e.message}")
raise ConfigIOError.new(origin, "#{e.class.name}: #{e.message}", e)
end
end
end
|
#parse_value(base_options = nil) ⇒ Object
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
# File 'lib/hocon/impl/parseable.rb', line 155
def parse_value(base_options = nil)
if base_options.nil?
base_options = options
end
options = fixup_options(base_options)
origin =
if options.origin_description
Hocon::Impl::SimpleConfigOrigin.new_simple(options.origin_description)
else
@initial_origin
end
parse_value_from_origin(origin, options)
end
|
#parse_value_from_origin(origin, final_options) ⇒ Object
176
177
178
179
180
181
182
183
184
185
186
187
|
# File 'lib/hocon/impl/parseable.rb', line 176
def parse_value_from_origin(origin, final_options)
begin
raw_parse_value(origin, final_options)
rescue IOError => e
if final_options.allow_missing?
Hocon::Impl::SimpleConfigObject.empty_missing(origin)
else
self.class.trace("exception loading #{origin.description}: #{e.class}: #{e.message}")
raise Hocon::ConfigError::ConfigIOError.new(origin, "#{e.class.name}: #{e.message}", e)
end
end
end
|
#post_construct(base_options) ⇒ Object
67
68
69
70
71
72
73
74
75
|
# File 'lib/hocon/impl/parseable.rb', line 67
def post_construct(base_options)
@initial_options = fixup_options(base_options)
@include_context = Hocon::Impl::SimpleIncludeContext.new(self)
if @initial_options.origin_description
@initial_origin = Hocon::Impl::SimpleConfigOrigin.new_simple(@initial_options.origin_description)
else
@initial_origin = create_origin
end
end
|
#raw_parse_document(origin, final_options) ⇒ Object
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
|
# File 'lib/hocon/impl/parseable.rb', line 253
def raw_parse_document(origin, final_options)
reader = reader(final_options)
content_type = content_type()
options_with_content_type = nil
if !(content_type.nil?)
if Hocon::Impl::ConfigImpl.trace_loads_enabled && (! final_options.get_syntax.nil?)
self.class.trace("Overriding syntax #{final_options.get_syntax} with Content-Type which specified #{content-type}")
end
options_with_content_type = final_options.set_syntax(content_type)
else
options_with_content_type = final_options
end
reader.open { |io|
raw_parse_document_from_io(io, origin, options_with_content_type)
}
end
|
#raw_parse_document_from_io(reader, origin, final_options) ⇒ Object
#raw_parse_value(origin, final_options) ⇒ Object
this is parseValue without post-processing the IOException or handling options.getAllowMissing()
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
|
# File 'lib/hocon/impl/parseable.rb', line 226
def raw_parse_value(origin, final_options)
reader = reader(final_options)
content_type = content_type()
options_with_content_type = nil
if !(content_type.nil?)
if Hocon::Impl::ConfigImpl.trace_loads_enabled && (! final_options.get_syntax.nil?)
self.class.trace("Overriding syntax #{final_options.get_syntax} with Content-Type which specified #{content-type}")
end
options_with_content_type = final_options.set_syntax(content_type)
else
options_with_content_type = final_options
end
reader.open { |io|
raw_parse_value_from_io(io, origin, options_with_content_type)
}
end
|
#raw_parse_value_from_io(io, origin, final_options) ⇒ Object
247
248
249
250
251
|
# File 'lib/hocon/impl/parseable.rb', line 247
def raw_parse_value_from_io(io, origin, final_options)
tokens = Hocon::Impl::Tokenizer.tokenize(origin, io, final_options.syntax)
document = Hocon::Impl::ConfigDocumentParser.parse(tokens, origin, final_options)
Hocon::Impl::ConfigParser.parse(document, origin, final_options, include_context)
end
|
#reader(options) ⇒ Object
88
89
90
|
# File 'lib/hocon/impl/parseable.rb', line 88
def reader(options)
custom_reader
end
|
#relative_to(filename) ⇒ Object
106
107
108
109
110
111
112
113
114
115
116
|
# File 'lib/hocon/impl/parseable.rb', line 106
def relative_to(filename)
resource = filename
if filename.start_with?("/")
resource = filename.slice(1)
end
self.class.new_resources(resource, options.set_origin_description(nil))
end
|
#to_s ⇒ Object
295
296
297
|
# File 'lib/hocon/impl/parseable.rb', line 295
def to_s
self.class.name.split('::').last
end
|