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.
@@ -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