rbjq 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/LICENSE +121 -0
- data/LICENSE-jq +176 -0
- data/README.md +155 -0
- data/exe/rbjq +25 -0
- data/lib/rbjq/bessel.rb +139 -0
- data/lib/rbjq/builtins.rb +1357 -0
- data/lib/rbjq/checker.rb +140 -0
- data/lib/rbjq/cli.rb +519 -0
- data/lib/rbjq/env.rb +39 -0
- data/lib/rbjq/formats.rb +98 -0
- data/lib/rbjq/functions.rb +137 -0
- data/lib/rbjq/interpreter.rb +726 -0
- data/lib/rbjq/json.rb +518 -0
- data/lib/rbjq/lexer.rb +183 -0
- data/lib/rbjq/ops.rb +449 -0
- data/lib/rbjq/parser.rb +584 -0
- data/lib/rbjq/prelude.rb +104 -0
- data/lib/rbjq/program.rb +106 -0
- data/lib/rbjq/value.rb +188 -0
- data/lib/rbjq/version.rb +5 -0
- data/lib/rbjq.rb +90 -0
- metadata +66 -0
|
@@ -0,0 +1,726 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
module Rbjq
|
|
4
|
+
# Raised from inside a `try` body's downstream so the try does not catch
|
|
5
|
+
# errors that happen after the body has produced a value.
|
|
6
|
+
class DownstreamError < StandardError
|
|
7
|
+
attr_reader :error, :marker
|
|
8
|
+
|
|
9
|
+
def initialize(error, marker)
|
|
10
|
+
super(error.message)
|
|
11
|
+
@error = error
|
|
12
|
+
@marker = marker
|
|
13
|
+
end
|
|
14
|
+
end
|
|
15
|
+
|
|
16
|
+
# Tree-walking evaluator. Every evaluation yields (value, path) pairs.
|
|
17
|
+
# `path` is nil when paths are not being tracked, an Array of path
|
|
18
|
+
# components when they are, or INVALID when the value is not a path.
|
|
19
|
+
class Interpreter
|
|
20
|
+
INVALID = Object.new.freeze
|
|
21
|
+
|
|
22
|
+
attr_reader :options
|
|
23
|
+
attr_accessor :input_provider, :global_env
|
|
24
|
+
|
|
25
|
+
def initialize(prelude:, natives:, options: {}, functions: {})
|
|
26
|
+
@prelude = prelude
|
|
27
|
+
@functions = functions
|
|
28
|
+
@natives = natives
|
|
29
|
+
@options = options
|
|
30
|
+
@global_env = nil
|
|
31
|
+
@input_provider = nil
|
|
32
|
+
@defer_operands = options.fetch(:defer_operands, true)
|
|
33
|
+
end
|
|
34
|
+
|
|
35
|
+
def run(ast, input, env = @global_env, &blk)
|
|
36
|
+
return enum_for(:run, ast, input, env) unless blk
|
|
37
|
+
|
|
38
|
+
eval_node(ast, input, nil, env) { |v, _| blk.call(v) }
|
|
39
|
+
end
|
|
40
|
+
|
|
41
|
+
# ---------------------------------------------------------------- eval
|
|
42
|
+
|
|
43
|
+
def eval_node(node, input, path, env, &blk)
|
|
44
|
+
case node[0]
|
|
45
|
+
when :identity
|
|
46
|
+
yield input, path
|
|
47
|
+
when :literal
|
|
48
|
+
yield node[1], path && INVALID
|
|
49
|
+
when :index
|
|
50
|
+
eval_index(node, input, path, env, &blk)
|
|
51
|
+
when :pipe
|
|
52
|
+
rhs = node[2]
|
|
53
|
+
eval_node(node[1], input, path, env) { |v, p| eval_node(rhs, v, p, env, &blk) }
|
|
54
|
+
when :comma
|
|
55
|
+
eval_node(node[1], input, path, env, &blk)
|
|
56
|
+
eval_node(node[2], input, path, env, &blk)
|
|
57
|
+
when :call
|
|
58
|
+
call_function(node, input, path, env, &blk)
|
|
59
|
+
when :iterate
|
|
60
|
+
eval_node(node[1], input, path, env) do |t, tp|
|
|
61
|
+
check_iterate_path!(t, tp) if path
|
|
62
|
+
iterate(t, tp, &blk)
|
|
63
|
+
end
|
|
64
|
+
when :slice
|
|
65
|
+
eval_slice(node, input, path, env, &blk)
|
|
66
|
+
when :binop
|
|
67
|
+
op = node[1]
|
|
68
|
+
lhs = node[2]
|
|
69
|
+
each_operand(node[3], input, env) do |r|
|
|
70
|
+
eval_node(lhs, input, nil, env) do |l|
|
|
71
|
+
yield Ops.binop(op, l, r), path && INVALID
|
|
72
|
+
end
|
|
73
|
+
end
|
|
74
|
+
when :and
|
|
75
|
+
rhs = node[2]
|
|
76
|
+
each_operand(node[1], input, env) do |l|
|
|
77
|
+
if Value.truthy?(l)
|
|
78
|
+
eval_node(rhs, input, nil, env) { |r| yield Value.truthy?(r), path && INVALID }
|
|
79
|
+
else
|
|
80
|
+
yield false, path && INVALID
|
|
81
|
+
end
|
|
82
|
+
end
|
|
83
|
+
when :or
|
|
84
|
+
rhs = node[2]
|
|
85
|
+
each_operand(node[1], input, env) do |l|
|
|
86
|
+
if Value.truthy?(l)
|
|
87
|
+
yield true, path && INVALID
|
|
88
|
+
else
|
|
89
|
+
eval_node(rhs, input, nil, env) { |r| yield Value.truthy?(r), path && INVALID }
|
|
90
|
+
end
|
|
91
|
+
end
|
|
92
|
+
when :alt
|
|
93
|
+
found = false
|
|
94
|
+
eval_node(node[1], input, path, env) do |v, p|
|
|
95
|
+
if Value.truthy?(v)
|
|
96
|
+
found = true
|
|
97
|
+
yield v, p
|
|
98
|
+
end
|
|
99
|
+
end
|
|
100
|
+
eval_node(node[2], input, path, env, &blk) unless found
|
|
101
|
+
when :neg
|
|
102
|
+
eval_node(node[1], input, nil, env) do |v|
|
|
103
|
+
raise JQError, "#{Value.desc(v)} cannot be negated" unless Value.number?(v)
|
|
104
|
+
|
|
105
|
+
yield(v.zero? && v.is_a?(Integer) ? -0.0 : Value.normalize_number(-v), path && INVALID)
|
|
106
|
+
end
|
|
107
|
+
when :if
|
|
108
|
+
cond = node[1]
|
|
109
|
+
eval_node(cond, input, nil, env) do |c|
|
|
110
|
+
if Value.truthy?(c)
|
|
111
|
+
eval_node(node[2], input, path, env, &blk)
|
|
112
|
+
elsif node[3]
|
|
113
|
+
eval_node(node[3], input, path, env, &blk)
|
|
114
|
+
else
|
|
115
|
+
yield input, path
|
|
116
|
+
end
|
|
117
|
+
end
|
|
118
|
+
when :try
|
|
119
|
+
eval_try(node, input, path, env, &blk)
|
|
120
|
+
when :var
|
|
121
|
+
yield lookup_var(node[1], env), path && INVALID
|
|
122
|
+
when :as
|
|
123
|
+
eval_as(node, input, path, env, &blk)
|
|
124
|
+
when :array
|
|
125
|
+
arr = []
|
|
126
|
+
eval_node(node[1], input, nil, env) { |v| arr << v } if node[1]
|
|
127
|
+
yield arr, path && INVALID
|
|
128
|
+
when :object
|
|
129
|
+
build_object(node[1], 0, {}, input, env) { |h| yield h, path && INVALID }
|
|
130
|
+
when :string
|
|
131
|
+
eval_string(node[1], node[1].size - 1, '', node[2], input, env) { |s| yield s, path && INVALID }
|
|
132
|
+
when :format
|
|
133
|
+
yield Formats.apply(node[1], input), path && INVALID
|
|
134
|
+
when :reduce
|
|
135
|
+
eval_reduce(node, input, path, env, &blk)
|
|
136
|
+
when :foreach
|
|
137
|
+
eval_foreach(node, input, path, env, &blk)
|
|
138
|
+
when :func_def
|
|
139
|
+
_, name, params, body, rest = node
|
|
140
|
+
fenv = Env.new(:func, "#{name}/#{params.size}", nil, env)
|
|
141
|
+
fenv.value = FuncDef.new(name, params, body, fenv)
|
|
142
|
+
eval_node(rest, input, path, fenv, &blk)
|
|
143
|
+
when :assign
|
|
144
|
+
eval_assign(node, input, path, env, &blk)
|
|
145
|
+
when :label
|
|
146
|
+
tag = Object.new
|
|
147
|
+
lenv = Env.new(:label, node[1], tag, env)
|
|
148
|
+
catch(tag) { eval_node(node[2], input, path, lenv, &blk) }
|
|
149
|
+
when :break
|
|
150
|
+
l = Env.lookup(env, :label, node[1])
|
|
151
|
+
raise JQError, "$*label-#{node[1]} is not defined" unless l
|
|
152
|
+
|
|
153
|
+
throw l.value
|
|
154
|
+
when :loc
|
|
155
|
+
yield({ 'file' => '<top-level>', 'line' => node[1] }, path && INVALID)
|
|
156
|
+
else
|
|
157
|
+
raise JQError, "unknown node #{node[0]}"
|
|
158
|
+
end
|
|
159
|
+
end
|
|
160
|
+
|
|
161
|
+
def check_path!(v, p)
|
|
162
|
+
return unless p.equal?(INVALID)
|
|
163
|
+
|
|
164
|
+
raise JQError, "Invalid path expression with result #{Value.dump_trunc(v)}"
|
|
165
|
+
end
|
|
166
|
+
|
|
167
|
+
# Messages follow jq; values are shortened like other error messages
|
|
168
|
+
def check_access_path!(t, tp, k)
|
|
169
|
+
return unless tp.equal?(INVALID)
|
|
170
|
+
|
|
171
|
+
raise JQError, 'Invalid path expression near attempt to access element ' \
|
|
172
|
+
"#{Value.dump_trunc(k)} of #{Value.dump_trunc(t)}"
|
|
173
|
+
end
|
|
174
|
+
|
|
175
|
+
def check_iterate_path!(t, tp)
|
|
176
|
+
return unless tp.equal?(INVALID)
|
|
177
|
+
|
|
178
|
+
raise JQError, "Invalid path expression near attempt to iterate through #{Value.dump_trunc(t)}"
|
|
179
|
+
end
|
|
180
|
+
|
|
181
|
+
def eval_index(node, input, path, env, &)
|
|
182
|
+
target = node[1]
|
|
183
|
+
key = node[2]
|
|
184
|
+
if key[0] == :literal
|
|
185
|
+
k = key[1]
|
|
186
|
+
eval_node(target, input, path, env) do |t, tp|
|
|
187
|
+
if path
|
|
188
|
+
check_access_path!(t, tp, k)
|
|
189
|
+
yield Ops.index(t, k), tp + [k]
|
|
190
|
+
else
|
|
191
|
+
yield Ops.index(t, k), nil
|
|
192
|
+
end
|
|
193
|
+
end
|
|
194
|
+
else
|
|
195
|
+
eval_node(key, input, nil, env) do |k|
|
|
196
|
+
eval_node(target, input, path, env) do |t, tp|
|
|
197
|
+
if path
|
|
198
|
+
check_access_path!(t, tp, k)
|
|
199
|
+
yield Ops.index(t, k), tp + [k]
|
|
200
|
+
else
|
|
201
|
+
yield Ops.index(t, k), nil
|
|
202
|
+
end
|
|
203
|
+
end
|
|
204
|
+
end
|
|
205
|
+
end
|
|
206
|
+
end
|
|
207
|
+
|
|
208
|
+
def eval_slice(node, input, path, env, &)
|
|
209
|
+
_, target, from_n, to_n = node
|
|
210
|
+
each_opt(from_n, input, env) do |from|
|
|
211
|
+
each_opt(to_n, input, env) do |to|
|
|
212
|
+
eval_node(target, input, path, env) do |t, tp|
|
|
213
|
+
v = Ops.slice(t, from, to)
|
|
214
|
+
if path
|
|
215
|
+
check_access_path!(t, tp, { 'start' => from, 'end' => to })
|
|
216
|
+
yield v, tp + [{ 'start' => from, 'end' => to }]
|
|
217
|
+
else
|
|
218
|
+
yield v, nil
|
|
219
|
+
end
|
|
220
|
+
end
|
|
221
|
+
end
|
|
222
|
+
end
|
|
223
|
+
end
|
|
224
|
+
|
|
225
|
+
def each_opt(node, input, env, &)
|
|
226
|
+
if node.nil?
|
|
227
|
+
yield nil
|
|
228
|
+
else
|
|
229
|
+
eval_node(node, input, nil, env, &)
|
|
230
|
+
end
|
|
231
|
+
end
|
|
232
|
+
|
|
233
|
+
def iterate(t, tp)
|
|
234
|
+
case t
|
|
235
|
+
when Array
|
|
236
|
+
if tp
|
|
237
|
+
t.each_with_index { |e, i| yield e, tp + [i] }
|
|
238
|
+
else
|
|
239
|
+
t.each { |e| yield e, nil }
|
|
240
|
+
end
|
|
241
|
+
when Hash
|
|
242
|
+
if tp
|
|
243
|
+
t.each { |k, v| yield v, tp + [k] }
|
|
244
|
+
else
|
|
245
|
+
t.each_value { |v| yield v, nil }
|
|
246
|
+
end
|
|
247
|
+
else
|
|
248
|
+
raise JQError, "Cannot iterate over #{Value.desc(t)}"
|
|
249
|
+
end
|
|
250
|
+
end
|
|
251
|
+
|
|
252
|
+
def eval_try(node, input, path, env, &)
|
|
253
|
+
body = node[1]
|
|
254
|
+
handler = node[2]
|
|
255
|
+
marker = Object.new
|
|
256
|
+
begin
|
|
257
|
+
eval_node(body, input, path, env) do |v, p|
|
|
258
|
+
yield v, p
|
|
259
|
+
rescue JQError => e
|
|
260
|
+
raise DownstreamError.new(e, marker)
|
|
261
|
+
end
|
|
262
|
+
rescue JQError => e
|
|
263
|
+
# the handler's input keeps the path only if it is the try's input itself
|
|
264
|
+
eval_node(handler, e.value, path && (e.value.equal?(input) ? path : INVALID), env, &) if handler
|
|
265
|
+
rescue DownstreamError => e
|
|
266
|
+
raise e.error if e.marker.equal?(marker)
|
|
267
|
+
|
|
268
|
+
raise
|
|
269
|
+
end
|
|
270
|
+
end
|
|
271
|
+
|
|
272
|
+
def lookup_var(name, env)
|
|
273
|
+
e = Env.lookup(env, :var, name)
|
|
274
|
+
return e.value if e
|
|
275
|
+
|
|
276
|
+
case name
|
|
277
|
+
when 'ENV' then ENV.to_h
|
|
278
|
+
else raise JQError, "$#{name} is not defined"
|
|
279
|
+
end
|
|
280
|
+
end
|
|
281
|
+
|
|
282
|
+
def eval_as(node, input, path, env, &blk)
|
|
283
|
+
_, src, patterns, body = node
|
|
284
|
+
eval_node(src, input, nil, env) do |v|
|
|
285
|
+
if patterns.size == 1
|
|
286
|
+
bind_pattern(patterns[0], v, input, env) { |e2| eval_node(body, input, path, e2, &blk) }
|
|
287
|
+
else
|
|
288
|
+
eval_alternatives(patterns, v, input, env, body, path, &blk)
|
|
289
|
+
end
|
|
290
|
+
end
|
|
291
|
+
end
|
|
292
|
+
|
|
293
|
+
def eval_alternatives(patterns, v, input, env, body, path, &blk)
|
|
294
|
+
names = patterns.flat_map { |pt| pattern_vars(pt) }.uniq
|
|
295
|
+
base = names.reduce(env) { |e, n| Env.bind_var(e, n, nil) }
|
|
296
|
+
patterns.each_with_index do |pat, i|
|
|
297
|
+
if i == patterns.size - 1
|
|
298
|
+
bind_pattern(pat, v, input, base) { |e2| eval_node(body, input, path, e2, &blk) }
|
|
299
|
+
break
|
|
300
|
+
end
|
|
301
|
+
|
|
302
|
+
marker = Object.new
|
|
303
|
+
begin
|
|
304
|
+
bind_pattern(pat, v, input, base) do |e2|
|
|
305
|
+
eval_node(body, input, path, e2) do |o, op|
|
|
306
|
+
yield o, op
|
|
307
|
+
rescue JQError => e
|
|
308
|
+
raise DownstreamError.new(e, marker)
|
|
309
|
+
end
|
|
310
|
+
end
|
|
311
|
+
break
|
|
312
|
+
rescue JQError
|
|
313
|
+
next
|
|
314
|
+
rescue DownstreamError => e
|
|
315
|
+
raise e.error if e.marker.equal?(marker)
|
|
316
|
+
|
|
317
|
+
raise
|
|
318
|
+
end
|
|
319
|
+
end
|
|
320
|
+
end
|
|
321
|
+
|
|
322
|
+
def pattern_vars(pat)
|
|
323
|
+
case pat[0]
|
|
324
|
+
when :pvar then [pat[1]]
|
|
325
|
+
when :parray then pat[1].flat_map { |pt| pattern_vars(pt) }
|
|
326
|
+
when :pobject
|
|
327
|
+
pat[1].flat_map do |(_, var, sub)|
|
|
328
|
+
(var ? [var] : []) + (sub ? pattern_vars(sub) : [])
|
|
329
|
+
end
|
|
330
|
+
end
|
|
331
|
+
end
|
|
332
|
+
|
|
333
|
+
def bind_pattern(pat, v, input, env, &)
|
|
334
|
+
case pat[0]
|
|
335
|
+
when :pvar
|
|
336
|
+
yield Env.bind_var(env, pat[1], v)
|
|
337
|
+
when :parray
|
|
338
|
+
bind_array(pat[1], 0, v, input, env, &)
|
|
339
|
+
when :pobject
|
|
340
|
+
bind_object(pat[1], 0, v, input, env, &)
|
|
341
|
+
end
|
|
342
|
+
end
|
|
343
|
+
|
|
344
|
+
def bind_array(pats, i, v, input, env, &blk)
|
|
345
|
+
if i == pats.size
|
|
346
|
+
yield env
|
|
347
|
+
return
|
|
348
|
+
end
|
|
349
|
+
Ops.index_error(v, i) unless v.nil? || v.is_a?(Array)
|
|
350
|
+
|
|
351
|
+
bind_pattern(pats[i], Ops.index(v, i), input, env) do |e2|
|
|
352
|
+
bind_array(pats, i + 1, v, input, e2, &blk)
|
|
353
|
+
end
|
|
354
|
+
end
|
|
355
|
+
|
|
356
|
+
def bind_object(entries, i, v, input, env, &blk)
|
|
357
|
+
if i == entries.size
|
|
358
|
+
yield env
|
|
359
|
+
return
|
|
360
|
+
end
|
|
361
|
+
key_node, var, sub = entries[i]
|
|
362
|
+
eval_node(key_node, input, nil, env) do |k|
|
|
363
|
+
raise JQError, "Cannot index #{Value.type_name(v)} with #{Value.type_name(k)}" unless k.is_a?(String)
|
|
364
|
+
|
|
365
|
+
val = Ops.index(v, k)
|
|
366
|
+
e2 = var ? Env.bind_var(env, var, val) : env
|
|
367
|
+
if sub
|
|
368
|
+
bind_pattern(sub, val, input, e2) { |e3| bind_object(entries, i + 1, v, input, e3, &blk) }
|
|
369
|
+
else
|
|
370
|
+
bind_object(entries, i + 1, v, input, e2, &blk)
|
|
371
|
+
end
|
|
372
|
+
end
|
|
373
|
+
end
|
|
374
|
+
|
|
375
|
+
def build_object(entries, i, acc, input, env, &blk)
|
|
376
|
+
if i == entries.size
|
|
377
|
+
yield acc
|
|
378
|
+
return
|
|
379
|
+
end
|
|
380
|
+
key_node, val_node = entries[i]
|
|
381
|
+
each_operand(key_node, input, env) do |k|
|
|
382
|
+
raise JQError, "Cannot use #{Value.desc(k)} as object key" unless k.is_a?(String)
|
|
383
|
+
|
|
384
|
+
each_operand(val_node, input, env) do |v|
|
|
385
|
+
h = acc.dup
|
|
386
|
+
h[k] = v
|
|
387
|
+
build_object(entries, i + 1, h, input, env, &blk)
|
|
388
|
+
end
|
|
389
|
+
end
|
|
390
|
+
end
|
|
391
|
+
|
|
392
|
+
def eval_string(parts, i, suffix, fmt, input, env, &blk)
|
|
393
|
+
if i.negative?
|
|
394
|
+
yield suffix
|
|
395
|
+
return
|
|
396
|
+
end
|
|
397
|
+
part = parts[i]
|
|
398
|
+
if part.is_a?(String)
|
|
399
|
+
eval_string(parts, i - 1, part + suffix, fmt, input, env, &blk)
|
|
400
|
+
else
|
|
401
|
+
each_operand(part, input, env) do |v|
|
|
402
|
+
s = fmt ? Formats.apply(fmt, v) : Ops.tostring(v)
|
|
403
|
+
eval_string(parts, i - 1, s + suffix, fmt, input, env, &blk)
|
|
404
|
+
end
|
|
405
|
+
end
|
|
406
|
+
end
|
|
407
|
+
|
|
408
|
+
def eval_reduce(node, input, path, env)
|
|
409
|
+
_, src, patterns, init, update = node
|
|
410
|
+
eval_node(init, input, path, env) do |iv, ip|
|
|
411
|
+
state = iv
|
|
412
|
+
eval_node(src, input, nil, env) do |x|
|
|
413
|
+
bind_for_loop(patterns, x, input, env) do |e2|
|
|
414
|
+
got = false
|
|
415
|
+
last = nil
|
|
416
|
+
eval_node(update, state, state_path(state, iv, ip), e2) do |v, _|
|
|
417
|
+
got = true
|
|
418
|
+
last = v
|
|
419
|
+
end
|
|
420
|
+
state = got ? last : nil
|
|
421
|
+
end
|
|
422
|
+
end
|
|
423
|
+
yield state, state_path(state, iv, ip)
|
|
424
|
+
end
|
|
425
|
+
end
|
|
426
|
+
|
|
427
|
+
# jq tracks paths by value identity: a loop state has the path of the
|
|
428
|
+
# initial value only while it still is that value.
|
|
429
|
+
def state_path(state, init, init_path)
|
|
430
|
+
return nil if init_path.nil?
|
|
431
|
+
|
|
432
|
+
state.equal?(init) ? init_path : INVALID
|
|
433
|
+
end
|
|
434
|
+
|
|
435
|
+
def eval_foreach(node, input, path, env, &block)
|
|
436
|
+
_, src, patterns, init, update, extract = node
|
|
437
|
+
eval_node(init, input, path, env) do |iv, ip|
|
|
438
|
+
state = iv
|
|
439
|
+
eval_node(src, input, nil, env) do |x|
|
|
440
|
+
bind_for_loop(patterns, x, input, env) do |e2|
|
|
441
|
+
eval_node(update, state, state_path(state, iv, ip), e2) do |v, p|
|
|
442
|
+
state = v
|
|
443
|
+
if extract
|
|
444
|
+
eval_node(extract, v, p, e2, &block)
|
|
445
|
+
else
|
|
446
|
+
yield v, p
|
|
447
|
+
end
|
|
448
|
+
end
|
|
449
|
+
end
|
|
450
|
+
end
|
|
451
|
+
end
|
|
452
|
+
end
|
|
453
|
+
|
|
454
|
+
def bind_for_loop(patterns, x, input, env, &blk)
|
|
455
|
+
if patterns.size == 1
|
|
456
|
+
bind_pattern(patterns[0], x, input, env, &blk)
|
|
457
|
+
else
|
|
458
|
+
names = patterns.flat_map { |pt| pattern_vars(pt) }.uniq
|
|
459
|
+
base = names.reduce(env) { |e, n| Env.bind_var(e, n, nil) }
|
|
460
|
+
patterns.each_with_index do |pat, i|
|
|
461
|
+
if i == patterns.size - 1
|
|
462
|
+
bind_pattern(pat, x, input, base, &blk)
|
|
463
|
+
else
|
|
464
|
+
envs = []
|
|
465
|
+
begin
|
|
466
|
+
bind_pattern(pat, x, input, base) { |e2| envs << e2 }
|
|
467
|
+
rescue JQError
|
|
468
|
+
next
|
|
469
|
+
end
|
|
470
|
+
envs.each(&blk)
|
|
471
|
+
end
|
|
472
|
+
break
|
|
473
|
+
end
|
|
474
|
+
end
|
|
475
|
+
end
|
|
476
|
+
|
|
477
|
+
# ------------------------------------------------------------ paths
|
|
478
|
+
|
|
479
|
+
def collect_paths(node, input, env)
|
|
480
|
+
paths = []
|
|
481
|
+
eval_node(node, input, [], env) do |v, p|
|
|
482
|
+
check_path!(v, p)
|
|
483
|
+
paths << p
|
|
484
|
+
end
|
|
485
|
+
paths
|
|
486
|
+
end
|
|
487
|
+
|
|
488
|
+
def eval_assign(node, input, path, env, &)
|
|
489
|
+
_, op, lhs, rhs = node
|
|
490
|
+
inv = path && INVALID
|
|
491
|
+
case op
|
|
492
|
+
when :'='
|
|
493
|
+
eval_node(rhs, input, nil, env) do |rv|
|
|
494
|
+
result = input
|
|
495
|
+
collect_paths(lhs, input, env).each { |p| result = Ops.setpath(result, p, rv) }
|
|
496
|
+
yield result, inv
|
|
497
|
+
end
|
|
498
|
+
when :'|='
|
|
499
|
+
yield modify(lhs, input, env) { |old, emit| eval_node(rhs, old, nil, env) { |v| emit.call(v) } }, inv
|
|
500
|
+
else
|
|
501
|
+
bop = op.to_s.chomp('=').to_sym
|
|
502
|
+
eval_node(rhs, input, nil, env) do |rv|
|
|
503
|
+
result = modify(lhs, input, env) do |old, emit|
|
|
504
|
+
if bop == :'//'
|
|
505
|
+
emit.call(Value.truthy?(old) ? old : rv)
|
|
506
|
+
else
|
|
507
|
+
emit.call(Ops.binop(bop, old, rv))
|
|
508
|
+
end
|
|
509
|
+
end
|
|
510
|
+
yield result, inv
|
|
511
|
+
end
|
|
512
|
+
end
|
|
513
|
+
end
|
|
514
|
+
|
|
515
|
+
# Implements _modify(paths; update): first output of update replaces the
|
|
516
|
+
# value at each path; paths where update is empty are deleted.
|
|
517
|
+
def modify(lhs, input, env, &updater)
|
|
518
|
+
result = input
|
|
519
|
+
dels = []
|
|
520
|
+
collect_paths(lhs, input, env).each do |p|
|
|
521
|
+
old = Ops.getpath(result, p)
|
|
522
|
+
tag = Object.new
|
|
523
|
+
found = false
|
|
524
|
+
newv = nil
|
|
525
|
+
catch(tag) do
|
|
526
|
+
updater.call(old, lambda do |v|
|
|
527
|
+
found = true
|
|
528
|
+
newv = v
|
|
529
|
+
throw tag
|
|
530
|
+
end)
|
|
531
|
+
end
|
|
532
|
+
if found
|
|
533
|
+
result = Ops.setpath(result, p, newv)
|
|
534
|
+
else
|
|
535
|
+
dels << p
|
|
536
|
+
end
|
|
537
|
+
end
|
|
538
|
+
result = Ops.delpaths(result, dels) unless dels.empty?
|
|
539
|
+
result
|
|
540
|
+
end
|
|
541
|
+
|
|
542
|
+
# ---------------------------------------------------------- functions
|
|
543
|
+
|
|
544
|
+
def call_function(node, input, path, env, &)
|
|
545
|
+
key = "#{node[1]}/#{node[2].size}"
|
|
546
|
+
e = Env.lookup(env, :func, key)
|
|
547
|
+
if e
|
|
548
|
+
f = e.value
|
|
549
|
+
if f.is_a?(Closure)
|
|
550
|
+
eval_node(f.node, input, path, f.env, &)
|
|
551
|
+
else
|
|
552
|
+
call_funcdef(f, node[2], input, path, env, &)
|
|
553
|
+
end
|
|
554
|
+
elsif (rf = @functions[key])
|
|
555
|
+
rf.call(self, input, path, node[2], env, &)
|
|
556
|
+
elsif (f = @prelude[key])
|
|
557
|
+
call_funcdef(f, node[2], input, path, env, &)
|
|
558
|
+
elsif (nf = @natives[key])
|
|
559
|
+
nf.call(self, input, path, node[2], env, &)
|
|
560
|
+
else
|
|
561
|
+
raise JQError, "#{key} is not defined"
|
|
562
|
+
end
|
|
563
|
+
end
|
|
564
|
+
|
|
565
|
+
def call_funcdef(f, args, input, path, caller_env, &blk)
|
|
566
|
+
params = f.params
|
|
567
|
+
if params.empty?
|
|
568
|
+
eval_node(f.body, input, path, f.env, &blk)
|
|
569
|
+
return
|
|
570
|
+
end
|
|
571
|
+
|
|
572
|
+
e = f.env
|
|
573
|
+
value_params = nil
|
|
574
|
+
params.each_with_index do |p, i|
|
|
575
|
+
if p.start_with?('$')
|
|
576
|
+
pname = p[1..]
|
|
577
|
+
e = Env.new(:func, "#{pname}/0", Closure.new(args[i], caller_env), e)
|
|
578
|
+
(value_params ||= []) << [pname, args[i]]
|
|
579
|
+
else
|
|
580
|
+
e = Env.new(:func, "#{p}/0", Closure.new(args[i], caller_env), e)
|
|
581
|
+
end
|
|
582
|
+
end
|
|
583
|
+
|
|
584
|
+
if value_params
|
|
585
|
+
bind_value_params(value_params, 0, input, caller_env, e) do |e2|
|
|
586
|
+
eval_node(f.body, input, path, e2, &blk)
|
|
587
|
+
end
|
|
588
|
+
else
|
|
589
|
+
eval_node(f.body, input, path, e, &blk)
|
|
590
|
+
end
|
|
591
|
+
end
|
|
592
|
+
|
|
593
|
+
def bind_value_params(vps, i, input, caller_env, env, &blk)
|
|
594
|
+
if i == vps.size
|
|
595
|
+
yield env
|
|
596
|
+
return
|
|
597
|
+
end
|
|
598
|
+
name, node = vps[i]
|
|
599
|
+
each_operand(node, input, caller_env) do |v|
|
|
600
|
+
bind_value_params(vps, i + 1, input, caller_env, Env.bind_var(env, name, v), &blk)
|
|
601
|
+
end
|
|
602
|
+
end
|
|
603
|
+
|
|
604
|
+
# Evaluate native-function arguments as a cartesian product
|
|
605
|
+
# (the last argument varies slowest, like jq's cfunctions).
|
|
606
|
+
def each_args(args, input, env, i = args.size - 1, acc = [], &blk)
|
|
607
|
+
if i.negative?
|
|
608
|
+
yield acc
|
|
609
|
+
return
|
|
610
|
+
end
|
|
611
|
+
each_operand(args[i], input, env) do |v|
|
|
612
|
+
each_args(args, input, env, i - 1, [v] + acc, &blk)
|
|
613
|
+
end
|
|
614
|
+
end
|
|
615
|
+
|
|
616
|
+
# Calls whose outputs should always be streamed (generators / side effects).
|
|
617
|
+
STREAMING_CALLS = %w[
|
|
618
|
+
range recurse repeat while until limit first input inputs debug stderr empty error
|
|
619
|
+
].to_set.freeze
|
|
620
|
+
|
|
621
|
+
# Evaluates an operand whose outputs drive an outer loop.
|
|
622
|
+
#
|
|
623
|
+
# Running the consumer inside the operand's yield stacks the consumer's
|
|
624
|
+
# frames on top of the operand's, so code such as
|
|
625
|
+
# `(. - 1 | f) + (. - 2 | f)` would need stack exponential in the
|
|
626
|
+
# recursion depth. For operands that end in a function call, the first
|
|
627
|
+
# output is held back until either the operand finishes (the common
|
|
628
|
+
# single-output case, consumed after the operand's frames are gone) or a
|
|
629
|
+
# second output arrives (from then on everything is streamed). On an
|
|
630
|
+
# error or a break, the held-back output is consumed first, so jq's
|
|
631
|
+
# output order is preserved.
|
|
632
|
+
def each_operand(node, input, env)
|
|
633
|
+
unless @defer_operands && deferrable?(node)
|
|
634
|
+
eval_node(node, input, nil, env) { |v, _| yield v }
|
|
635
|
+
return
|
|
636
|
+
end
|
|
637
|
+
|
|
638
|
+
pending = false
|
|
639
|
+
buffered = nil
|
|
640
|
+
streaming = false
|
|
641
|
+
completed = false
|
|
642
|
+
raised = false
|
|
643
|
+
begin
|
|
644
|
+
eval_node(node, input, nil, env) do |v, _|
|
|
645
|
+
if streaming
|
|
646
|
+
yield v
|
|
647
|
+
elsif pending
|
|
648
|
+
streaming = true
|
|
649
|
+
pending = false
|
|
650
|
+
yield buffered
|
|
651
|
+
yield v
|
|
652
|
+
else
|
|
653
|
+
buffered = v
|
|
654
|
+
pending = true
|
|
655
|
+
end
|
|
656
|
+
end
|
|
657
|
+
completed = true
|
|
658
|
+
rescue Exception => e # rubocop:disable Lint/RescueException
|
|
659
|
+
raised = true
|
|
660
|
+
if pending && (e.is_a?(JQError) || e.is_a?(HaltError))
|
|
661
|
+
pending = false
|
|
662
|
+
yield buffered
|
|
663
|
+
end
|
|
664
|
+
raise
|
|
665
|
+
ensure
|
|
666
|
+
# normal completion, or unwinding by throw (label/break, limit, first)
|
|
667
|
+
if pending && (completed || !raised)
|
|
668
|
+
pending = false
|
|
669
|
+
yield buffered
|
|
670
|
+
end
|
|
671
|
+
end
|
|
672
|
+
end
|
|
673
|
+
|
|
674
|
+
def deferrable?(node)
|
|
675
|
+
case node[0]
|
|
676
|
+
when :call then !STREAMING_CALLS.include?(node[1])
|
|
677
|
+
when :pipe then single?(node[1]) && deferrable?(node[2])
|
|
678
|
+
else false
|
|
679
|
+
end
|
|
680
|
+
end
|
|
681
|
+
|
|
682
|
+
# Statically known to produce exactly one output (or an error).
|
|
683
|
+
def single?(node)
|
|
684
|
+
case node[0]
|
|
685
|
+
when :literal, :var, :identity, :loc, :format, :array then true
|
|
686
|
+
when :index then single?(node[1]) && single?(node[2])
|
|
687
|
+
when :slice then single?(node[1]) && (node[2].nil? || single?(node[2])) && (node[3].nil? || single?(node[3]))
|
|
688
|
+
when :binop then single?(node[2]) && single?(node[3])
|
|
689
|
+
when :neg then single?(node[1])
|
|
690
|
+
when :and, :or then single?(node[1]) && single?(node[2])
|
|
691
|
+
when :object then node[1].all? { |k, v| single?(k) && single?(v) }
|
|
692
|
+
when :string then node[1].all? { |p| p.is_a?(String) || single?(p) }
|
|
693
|
+
when :pipe then single?(node[1]) && single?(node[2])
|
|
694
|
+
else false
|
|
695
|
+
end
|
|
696
|
+
end
|
|
697
|
+
|
|
698
|
+
def first_value(node, input, env)
|
|
699
|
+
tag = Object.new
|
|
700
|
+
result = nil
|
|
701
|
+
found = false
|
|
702
|
+
catch(tag) do
|
|
703
|
+
eval_node(node, input, nil, env) do |v|
|
|
704
|
+
result = v
|
|
705
|
+
found = true
|
|
706
|
+
throw tag
|
|
707
|
+
end
|
|
708
|
+
end
|
|
709
|
+
[found, result]
|
|
710
|
+
end
|
|
711
|
+
|
|
712
|
+
def next_input
|
|
713
|
+
# jq raises "break" when there are no more inputs (`inputs` catches it)
|
|
714
|
+
raise JQError, 'break' unless @input_provider
|
|
715
|
+
|
|
716
|
+
v = @input_provider.call
|
|
717
|
+
raise JQError, 'break' if v.equal?(JSONParser::EOF)
|
|
718
|
+
|
|
719
|
+
v
|
|
720
|
+
end
|
|
721
|
+
|
|
722
|
+
def current_filename
|
|
723
|
+
@options[:filename_proc]&.call
|
|
724
|
+
end
|
|
725
|
+
end
|
|
726
|
+
end
|