ripper_ruby_parser 1.7.0 → 1.9.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 +4 -4
- data/CHANGELOG.md +76 -0
- data/README.md +6 -4
- data/lib/ripper_ruby_parser/commenting_ripper_parser.rb +24 -12
- data/lib/ripper_ruby_parser/sexp_handlers.rb +2 -0
- data/lib/ripper_ruby_parser/sexp_handlers/assignment.rb +9 -4
- data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb +40 -52
- data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb +17 -19
- data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb +35 -2
- data/lib/ripper_ruby_parser/sexp_handlers/literals.rb +15 -242
- data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb +9 -5
- data/lib/ripper_ruby_parser/sexp_handlers/methods.rb +22 -17
- data/lib/ripper_ruby_parser/sexp_handlers/operators.rb +3 -3
- data/lib/ripper_ruby_parser/sexp_handlers/string_literals.rb +256 -0
- data/lib/ripper_ruby_parser/sexp_processor.rb +12 -56
- data/lib/ripper_ruby_parser/unescape.rb +89 -43
- data/lib/ripper_ruby_parser/version.rb +1 -1
- metadata +125 -76
- data/Rakefile +0 -33
- data/test/end_to_end/comments_test.rb +0 -59
- data/test/end_to_end/comparison_test.rb +0 -104
- data/test/end_to_end/lib_comparison_test.rb +0 -29
- data/test/end_to_end/line_numbering_test.rb +0 -31
- data/test/end_to_end/samples_comparison_test.rb +0 -13
- data/test/end_to_end/test_comparison_test.rb +0 -32
- data/test/pt_testcase/pt_test.rb +0 -44
- data/test/ripper_ruby_parser/commenting_ripper_parser_test.rb +0 -200
- data/test/ripper_ruby_parser/parser_test.rb +0 -553
- data/test/ripper_ruby_parser/sexp_handlers/assignment_test.rb +0 -613
- data/test/ripper_ruby_parser/sexp_handlers/blocks_test.rb +0 -679
- data/test/ripper_ruby_parser/sexp_handlers/conditionals_test.rb +0 -536
- data/test/ripper_ruby_parser/sexp_handlers/literals_test.rb +0 -1106
- data/test/ripper_ruby_parser/sexp_handlers/loops_test.rb +0 -209
- data/test/ripper_ruby_parser/sexp_handlers/method_calls_test.rb +0 -267
- data/test/ripper_ruby_parser/sexp_handlers/methods_test.rb +0 -421
- data/test/ripper_ruby_parser/sexp_handlers/operators_test.rb +0 -399
- data/test/ripper_ruby_parser/sexp_processor_test.rb +0 -303
- data/test/ripper_ruby_parser/version_test.rb +0 -7
- data/test/samples/assignment.rb +0 -17
- data/test/samples/comments.rb +0 -13
- data/test/samples/conditionals.rb +0 -23
- data/test/samples/lambdas.rb +0 -5
- data/test/samples/loops.rb +0 -36
- data/test/samples/misc.rb +0 -281
- data/test/samples/number.rb +0 -7
- data/test/samples/operators.rb +0 -18
- data/test/samples/strings.rb +0 -147
- data/test/test_helper.rb +0 -107
|
@@ -1,679 +0,0 @@
|
|
|
1
|
-
# frozen_string_literal: true
|
|
2
|
-
|
|
3
|
-
require File.expand_path("../../test_helper.rb", File.dirname(__FILE__))
|
|
4
|
-
|
|
5
|
-
describe RipperRubyParser::Parser do
|
|
6
|
-
describe "#parse" do
|
|
7
|
-
describe "for do blocks" do
|
|
8
|
-
it "works with no statements in the block body" do
|
|
9
|
-
_("foo do; end")
|
|
10
|
-
.must_be_parsed_as s(:iter,
|
|
11
|
-
s(:call, nil, :foo),
|
|
12
|
-
0)
|
|
13
|
-
end
|
|
14
|
-
|
|
15
|
-
it "works with redo" do
|
|
16
|
-
_("foo do; redo; end")
|
|
17
|
-
.must_be_parsed_as s(:iter,
|
|
18
|
-
s(:call, nil, :foo),
|
|
19
|
-
0,
|
|
20
|
-
s(:redo))
|
|
21
|
-
end
|
|
22
|
-
|
|
23
|
-
it "works with nested begin..end" do
|
|
24
|
-
_("foo do; begin; bar; end; end;")
|
|
25
|
-
.must_be_parsed_as s(:iter,
|
|
26
|
-
s(:call, nil, :foo),
|
|
27
|
-
0,
|
|
28
|
-
s(:call, nil, :bar))
|
|
29
|
-
end
|
|
30
|
-
|
|
31
|
-
it "works with nested begin..end plus other statements" do
|
|
32
|
-
_("foo do; bar; begin; baz; end; end;")
|
|
33
|
-
.must_be_parsed_as s(:iter,
|
|
34
|
-
s(:call, nil, :foo),
|
|
35
|
-
0,
|
|
36
|
-
s(:block,
|
|
37
|
-
s(:call, nil, :bar),
|
|
38
|
-
s(:call, nil, :baz)))
|
|
39
|
-
end
|
|
40
|
-
end
|
|
41
|
-
|
|
42
|
-
describe "for brace blocks" do
|
|
43
|
-
it "works with no statements in the block body" do
|
|
44
|
-
_("foo { }")
|
|
45
|
-
.must_be_parsed_as s(:iter,
|
|
46
|
-
s(:call, nil, :foo),
|
|
47
|
-
0)
|
|
48
|
-
end
|
|
49
|
-
end
|
|
50
|
-
|
|
51
|
-
describe "for block parameters" do
|
|
52
|
-
specify do
|
|
53
|
-
_("foo do |(bar, baz)| end")
|
|
54
|
-
.must_be_parsed_as s(:iter,
|
|
55
|
-
s(:call, nil, :foo),
|
|
56
|
-
s(:args,
|
|
57
|
-
s(:masgn, :bar, :baz)))
|
|
58
|
-
end
|
|
59
|
-
|
|
60
|
-
specify do
|
|
61
|
-
_("foo do |(bar, *baz)| end")
|
|
62
|
-
.must_be_parsed_as s(:iter,
|
|
63
|
-
s(:call, nil, :foo),
|
|
64
|
-
s(:args,
|
|
65
|
-
s(:masgn, :bar, :"*baz")))
|
|
66
|
-
end
|
|
67
|
-
|
|
68
|
-
specify do
|
|
69
|
-
_("foo do |bar,*| end")
|
|
70
|
-
.must_be_parsed_as s(:iter,
|
|
71
|
-
s(:call, nil, :foo),
|
|
72
|
-
s(:args, :bar, :"*"))
|
|
73
|
-
end
|
|
74
|
-
|
|
75
|
-
specify do
|
|
76
|
-
_("foo do |bar, &baz| end")
|
|
77
|
-
.must_be_parsed_as s(:iter,
|
|
78
|
-
s(:call, nil, :foo),
|
|
79
|
-
s(:args, :bar, :"&baz"))
|
|
80
|
-
end
|
|
81
|
-
|
|
82
|
-
it "handles absent parameter specs" do
|
|
83
|
-
_("foo do; bar; end")
|
|
84
|
-
.must_be_parsed_as s(:iter,
|
|
85
|
-
s(:call, nil, :foo),
|
|
86
|
-
0,
|
|
87
|
-
s(:call, nil, :bar))
|
|
88
|
-
end
|
|
89
|
-
|
|
90
|
-
it "handles empty parameter specs" do
|
|
91
|
-
_("foo do ||; bar; end")
|
|
92
|
-
.must_be_parsed_as s(:iter,
|
|
93
|
-
s(:call, nil, :foo),
|
|
94
|
-
s(:args),
|
|
95
|
-
s(:call, nil, :bar))
|
|
96
|
-
end
|
|
97
|
-
|
|
98
|
-
it "handles a trailing comma in the block parameters" do
|
|
99
|
-
_("foo do |bar, | end")
|
|
100
|
-
.must_be_parsed_as s(:iter,
|
|
101
|
-
s(:call, nil, :foo),
|
|
102
|
-
s(:args, :bar, nil))
|
|
103
|
-
end
|
|
104
|
-
|
|
105
|
-
it "works with zero arguments" do
|
|
106
|
-
_("foo do ||; end")
|
|
107
|
-
.must_be_parsed_as s(:iter,
|
|
108
|
-
s(:call, nil, :foo),
|
|
109
|
-
s(:args))
|
|
110
|
-
end
|
|
111
|
-
|
|
112
|
-
it "works with one argument" do
|
|
113
|
-
_("foo do |bar|; end")
|
|
114
|
-
.must_be_parsed_as s(:iter,
|
|
115
|
-
s(:call, nil, :foo),
|
|
116
|
-
s(:args, :bar))
|
|
117
|
-
end
|
|
118
|
-
|
|
119
|
-
it "works with multiple arguments" do
|
|
120
|
-
_("foo do |bar, baz|; end")
|
|
121
|
-
.must_be_parsed_as s(:iter,
|
|
122
|
-
s(:call, nil, :foo),
|
|
123
|
-
s(:args, :bar, :baz))
|
|
124
|
-
end
|
|
125
|
-
|
|
126
|
-
it "works with an argument with a default value" do
|
|
127
|
-
_("foo do |bar=baz|; end")
|
|
128
|
-
.must_be_parsed_as s(:iter,
|
|
129
|
-
s(:call, nil, :foo),
|
|
130
|
-
s(:args,
|
|
131
|
-
s(:lasgn, :bar, s(:call, nil, :baz))))
|
|
132
|
-
end
|
|
133
|
-
|
|
134
|
-
it "works with a keyword argument with no default value" do
|
|
135
|
-
_("foo do |bar:|; end")
|
|
136
|
-
.must_be_parsed_as s(:iter,
|
|
137
|
-
s(:call, nil, :foo),
|
|
138
|
-
s(:args,
|
|
139
|
-
s(:kwarg, :bar)))
|
|
140
|
-
end
|
|
141
|
-
|
|
142
|
-
it "works with a keyword argument with a default value" do
|
|
143
|
-
_("foo do |bar: baz|; end")
|
|
144
|
-
.must_be_parsed_as s(:iter,
|
|
145
|
-
s(:call, nil, :foo),
|
|
146
|
-
s(:args,
|
|
147
|
-
s(:kwarg, :bar, s(:call, nil, :baz))))
|
|
148
|
-
end
|
|
149
|
-
|
|
150
|
-
it "works with a single splat argument" do
|
|
151
|
-
_("foo do |*bar|; end")
|
|
152
|
-
.must_be_parsed_as s(:iter,
|
|
153
|
-
s(:call, nil, :foo),
|
|
154
|
-
s(:args, :"*bar"))
|
|
155
|
-
end
|
|
156
|
-
|
|
157
|
-
it "works with a combination of regular arguments and a splat argument" do
|
|
158
|
-
_("foo do |bar, *baz|; end")
|
|
159
|
-
.must_be_parsed_as s(:iter,
|
|
160
|
-
s(:call, nil, :foo),
|
|
161
|
-
s(:args, :bar, :"*baz"))
|
|
162
|
-
end
|
|
163
|
-
|
|
164
|
-
it "works with a kwrest argument" do
|
|
165
|
-
_("foo do |**bar|; baz bar; end")
|
|
166
|
-
.must_be_parsed_as s(:iter,
|
|
167
|
-
s(:call, nil, :foo),
|
|
168
|
-
s(:args, :"**bar"),
|
|
169
|
-
s(:call, nil, :baz,
|
|
170
|
-
s(:lvar, :bar)))
|
|
171
|
-
end
|
|
172
|
-
|
|
173
|
-
it "works with a regular argument after a splat argument" do
|
|
174
|
-
_("foo do |*bar, baz|; end")
|
|
175
|
-
.must_be_parsed_as s(:iter,
|
|
176
|
-
s(:call, nil, :foo),
|
|
177
|
-
s(:args, :"*bar", :baz))
|
|
178
|
-
end
|
|
179
|
-
|
|
180
|
-
it "works with a combination of regular arguments and a kwrest argument" do
|
|
181
|
-
_("foo do |bar, **baz|; qux bar, baz; end")
|
|
182
|
-
.must_be_parsed_as s(:iter,
|
|
183
|
-
s(:call, nil, :foo),
|
|
184
|
-
s(:args, :bar, :"**baz"),
|
|
185
|
-
s(:call, nil, :qux,
|
|
186
|
-
s(:lvar, :bar),
|
|
187
|
-
s(:lvar, :baz)))
|
|
188
|
-
end
|
|
189
|
-
end
|
|
190
|
-
|
|
191
|
-
describe "for begin" do
|
|
192
|
-
it "works for an empty begin..end block" do
|
|
193
|
-
_("begin end").must_be_parsed_as s(:nil)
|
|
194
|
-
end
|
|
195
|
-
|
|
196
|
-
it "works for a simple begin..end block" do
|
|
197
|
-
_("begin; foo; end").must_be_parsed_as s(:call, nil, :foo)
|
|
198
|
-
end
|
|
199
|
-
|
|
200
|
-
it "works for begin..end block with more than one statement" do
|
|
201
|
-
_("begin; foo; bar; end")
|
|
202
|
-
.must_be_parsed_as s(:block,
|
|
203
|
-
s(:call, nil, :foo),
|
|
204
|
-
s(:call, nil, :bar))
|
|
205
|
-
end
|
|
206
|
-
|
|
207
|
-
it "keeps :begin for the truepart of a postfix if" do
|
|
208
|
-
_("begin; foo; end if bar")
|
|
209
|
-
.must_be_parsed_as s(:if,
|
|
210
|
-
s(:call, nil, :bar),
|
|
211
|
-
s(:begin, s(:call, nil, :foo)),
|
|
212
|
-
nil)
|
|
213
|
-
end
|
|
214
|
-
|
|
215
|
-
it "keeps :begin for the falsepart of a postfix unless" do
|
|
216
|
-
_("begin; foo; end unless bar")
|
|
217
|
-
.must_be_parsed_as s(:if,
|
|
218
|
-
s(:call, nil, :bar),
|
|
219
|
-
nil,
|
|
220
|
-
s(:begin, s(:call, nil, :foo)))
|
|
221
|
-
end
|
|
222
|
-
end
|
|
223
|
-
|
|
224
|
-
describe "for rescue/else" do
|
|
225
|
-
it "works for a block with multiple rescue statements" do
|
|
226
|
-
_("begin foo; rescue; bar; rescue; baz; end")
|
|
227
|
-
.must_be_parsed_as s(:rescue,
|
|
228
|
-
s(:call, nil, :foo),
|
|
229
|
-
s(:resbody,
|
|
230
|
-
s(:array),
|
|
231
|
-
s(:call, nil, :bar)),
|
|
232
|
-
s(:resbody,
|
|
233
|
-
s(:array),
|
|
234
|
-
s(:call, nil, :baz)))
|
|
235
|
-
end
|
|
236
|
-
|
|
237
|
-
it "works for a block with rescue and else" do
|
|
238
|
-
_("begin; foo; rescue; bar; else; baz; end")
|
|
239
|
-
.must_be_parsed_as s(:rescue,
|
|
240
|
-
s(:call, nil, :foo),
|
|
241
|
-
s(:resbody,
|
|
242
|
-
s(:array),
|
|
243
|
-
s(:call, nil, :bar)),
|
|
244
|
-
s(:call, nil, :baz))
|
|
245
|
-
end
|
|
246
|
-
|
|
247
|
-
it "works for a block with only else" do
|
|
248
|
-
_("begin; foo; else; bar; end")
|
|
249
|
-
.must_be_parsed_as s(:block,
|
|
250
|
-
s(:call, nil, :foo),
|
|
251
|
-
s(:call, nil, :bar))
|
|
252
|
-
end
|
|
253
|
-
end
|
|
254
|
-
|
|
255
|
-
describe "for the rescue statement" do
|
|
256
|
-
it "works with assignment to an error variable" do
|
|
257
|
-
_("begin; foo; rescue => bar; baz; end")
|
|
258
|
-
.must_be_parsed_as s(:rescue,
|
|
259
|
-
s(:call, nil, :foo),
|
|
260
|
-
s(:resbody,
|
|
261
|
-
s(:array,
|
|
262
|
-
s(:lasgn, :bar, s(:gvar, :$!))),
|
|
263
|
-
s(:call, nil, :baz)))
|
|
264
|
-
end
|
|
265
|
-
|
|
266
|
-
it "works with assignment of the exception to an instance variable" do
|
|
267
|
-
_("begin; foo; rescue => @bar; baz; end")
|
|
268
|
-
.must_be_parsed_as s(:rescue,
|
|
269
|
-
s(:call, nil, :foo),
|
|
270
|
-
s(:resbody,
|
|
271
|
-
s(:array,
|
|
272
|
-
s(:iasgn, :@bar, s(:gvar, :$!))),
|
|
273
|
-
s(:call, nil, :baz)))
|
|
274
|
-
end
|
|
275
|
-
|
|
276
|
-
it "works with empty main and rescue bodies" do
|
|
277
|
-
_("begin; rescue; end")
|
|
278
|
-
.must_be_parsed_as s(:rescue,
|
|
279
|
-
s(:resbody, s(:array), nil))
|
|
280
|
-
end
|
|
281
|
-
|
|
282
|
-
it "works with single statement main and rescue bodies" do
|
|
283
|
-
_("begin; foo; rescue; bar; end")
|
|
284
|
-
.must_be_parsed_as s(:rescue,
|
|
285
|
-
s(:call, nil, :foo),
|
|
286
|
-
s(:resbody,
|
|
287
|
-
s(:array),
|
|
288
|
-
s(:call, nil, :bar)))
|
|
289
|
-
end
|
|
290
|
-
|
|
291
|
-
it "works with multi-statement main and rescue bodies" do
|
|
292
|
-
_("begin; foo; bar; rescue; baz; qux; end")
|
|
293
|
-
.must_be_parsed_as s(:rescue,
|
|
294
|
-
s(:block,
|
|
295
|
-
s(:call, nil, :foo),
|
|
296
|
-
s(:call, nil, :bar)),
|
|
297
|
-
s(:resbody,
|
|
298
|
-
s(:array),
|
|
299
|
-
s(:call, nil, :baz),
|
|
300
|
-
s(:call, nil, :qux)))
|
|
301
|
-
end
|
|
302
|
-
|
|
303
|
-
it "works with assignment to an error variable" do
|
|
304
|
-
_("begin; foo; rescue => e; bar; end")
|
|
305
|
-
.must_be_parsed_as s(:rescue,
|
|
306
|
-
s(:call, nil, :foo),
|
|
307
|
-
s(:resbody,
|
|
308
|
-
s(:array, s(:lasgn, :e, s(:gvar, :$!))),
|
|
309
|
-
s(:call, nil, :bar)))
|
|
310
|
-
end
|
|
311
|
-
|
|
312
|
-
it "works with filtering of the exception type" do
|
|
313
|
-
_("begin; foo; rescue Bar; baz; end")
|
|
314
|
-
.must_be_parsed_as s(:rescue,
|
|
315
|
-
s(:call, nil, :foo),
|
|
316
|
-
s(:resbody,
|
|
317
|
-
s(:array, s(:const, :Bar)),
|
|
318
|
-
s(:call, nil, :baz)))
|
|
319
|
-
end
|
|
320
|
-
|
|
321
|
-
it "works with filtering of the exception type and assignment to an error variable" do
|
|
322
|
-
_("begin; foo; rescue Bar => e; baz; end")
|
|
323
|
-
.must_be_parsed_as s(:rescue,
|
|
324
|
-
s(:call, nil, :foo),
|
|
325
|
-
s(:resbody,
|
|
326
|
-
s(:array,
|
|
327
|
-
s(:const, :Bar),
|
|
328
|
-
s(:lasgn, :e, s(:gvar, :$!))),
|
|
329
|
-
s(:call, nil, :baz)))
|
|
330
|
-
end
|
|
331
|
-
|
|
332
|
-
it "works rescuing multiple exception types" do
|
|
333
|
-
_("begin; foo; rescue Bar, Baz; qux; end")
|
|
334
|
-
.must_be_parsed_as s(:rescue,
|
|
335
|
-
s(:call, nil, :foo),
|
|
336
|
-
s(:resbody,
|
|
337
|
-
s(:array, s(:const, :Bar), s(:const, :Baz)),
|
|
338
|
-
s(:call, nil, :qux)))
|
|
339
|
-
end
|
|
340
|
-
|
|
341
|
-
it "works rescuing a splatted list of exception types" do
|
|
342
|
-
_("begin; foo; rescue *bar; baz; end")
|
|
343
|
-
.must_be_parsed_as s(:rescue,
|
|
344
|
-
s(:call, nil, :foo),
|
|
345
|
-
s(:resbody,
|
|
346
|
-
s(:splat, s(:call, nil, :bar)),
|
|
347
|
-
s(:call, nil, :baz)))
|
|
348
|
-
end
|
|
349
|
-
|
|
350
|
-
it "works rescuing a complex list of exception types" do
|
|
351
|
-
_("begin; foo; rescue *bar, Baz; qux; end")
|
|
352
|
-
.must_be_parsed_as s(:rescue,
|
|
353
|
-
s(:call, nil, :foo),
|
|
354
|
-
s(:resbody,
|
|
355
|
-
s(:array,
|
|
356
|
-
s(:splat, s(:call, nil, :bar)),
|
|
357
|
-
s(:const, :Baz)),
|
|
358
|
-
s(:call, nil, :qux)))
|
|
359
|
-
end
|
|
360
|
-
|
|
361
|
-
it "works with a nested begin..end block" do
|
|
362
|
-
_("begin; foo; rescue; begin; bar; end; end")
|
|
363
|
-
.must_be_parsed_as s(:rescue,
|
|
364
|
-
s(:call, nil, :foo),
|
|
365
|
-
s(:resbody, s(:array),
|
|
366
|
-
s(:call, nil, :bar)))
|
|
367
|
-
end
|
|
368
|
-
|
|
369
|
-
it "works in a plain method body" do
|
|
370
|
-
_("def foo; bar; rescue; baz; end")
|
|
371
|
-
.must_be_parsed_as s(:defn,
|
|
372
|
-
:foo,
|
|
373
|
-
s(:args),
|
|
374
|
-
s(:rescue,
|
|
375
|
-
s(:call, nil, :bar),
|
|
376
|
-
s(:resbody,
|
|
377
|
-
s(:array),
|
|
378
|
-
s(:call, nil, :baz))))
|
|
379
|
-
end
|
|
380
|
-
|
|
381
|
-
it "works in a method body inside begin..end with rescue" do
|
|
382
|
-
_("def foo; bar; begin; baz; rescue; qux; end; quuz; end")
|
|
383
|
-
.must_be_parsed_as s(:defn,
|
|
384
|
-
:foo,
|
|
385
|
-
s(:args),
|
|
386
|
-
s(:call, nil, :bar),
|
|
387
|
-
s(:rescue,
|
|
388
|
-
s(:call, nil, :baz),
|
|
389
|
-
s(:resbody, s(:array), s(:call, nil, :qux))),
|
|
390
|
-
s(:call, nil, :quuz))
|
|
391
|
-
end
|
|
392
|
-
|
|
393
|
-
it "works in a method body inside begin..end without rescue" do
|
|
394
|
-
_("def foo; bar; begin; baz; qux; end; quuz; end")
|
|
395
|
-
.must_be_parsed_as s(:defn,
|
|
396
|
-
:foo,
|
|
397
|
-
s(:args),
|
|
398
|
-
s(:call, nil, :bar),
|
|
399
|
-
s(:block,
|
|
400
|
-
s(:call, nil, :baz),
|
|
401
|
-
s(:call, nil, :qux)),
|
|
402
|
-
s(:call, nil, :quuz))
|
|
403
|
-
end
|
|
404
|
-
|
|
405
|
-
it "works in a method body fully inside begin..end" do
|
|
406
|
-
_("def foo; begin; bar; baz; end; end")
|
|
407
|
-
.must_be_parsed_as s(:defn,
|
|
408
|
-
:foo,
|
|
409
|
-
s(:args),
|
|
410
|
-
s(:call, nil, :bar),
|
|
411
|
-
s(:call, nil, :baz))
|
|
412
|
-
end
|
|
413
|
-
end
|
|
414
|
-
|
|
415
|
-
describe "for the postfix rescue modifier" do
|
|
416
|
-
it "works in the basic case" do
|
|
417
|
-
_("foo rescue bar")
|
|
418
|
-
.must_be_parsed_as s(:rescue,
|
|
419
|
-
s(:call, nil, :foo),
|
|
420
|
-
s(:resbody,
|
|
421
|
-
s(:array),
|
|
422
|
-
s(:call, nil, :bar)))
|
|
423
|
-
end
|
|
424
|
-
|
|
425
|
-
it "works when the fallback value is a keyword" do
|
|
426
|
-
_("foo rescue next")
|
|
427
|
-
.must_be_parsed_as s(:rescue,
|
|
428
|
-
s(:call, nil, :foo),
|
|
429
|
-
s(:resbody,
|
|
430
|
-
s(:array),
|
|
431
|
-
s(:next)))
|
|
432
|
-
end
|
|
433
|
-
end
|
|
434
|
-
|
|
435
|
-
describe "for the ensure statement" do
|
|
436
|
-
it "works with single statement main and ensure bodies" do
|
|
437
|
-
_("begin; foo; ensure; bar; end")
|
|
438
|
-
.must_be_parsed_as s(:ensure,
|
|
439
|
-
s(:call, nil, :foo),
|
|
440
|
-
s(:call, nil, :bar))
|
|
441
|
-
end
|
|
442
|
-
|
|
443
|
-
it "works with multi-statement main and ensure bodies" do
|
|
444
|
-
_("begin; foo; bar; ensure; baz; qux; end")
|
|
445
|
-
.must_be_parsed_as s(:ensure,
|
|
446
|
-
s(:block,
|
|
447
|
-
s(:call, nil, :foo),
|
|
448
|
-
s(:call, nil, :bar)),
|
|
449
|
-
s(:block,
|
|
450
|
-
s(:call, nil, :baz),
|
|
451
|
-
s(:call, nil, :qux)))
|
|
452
|
-
end
|
|
453
|
-
|
|
454
|
-
it "works together with rescue" do
|
|
455
|
-
_("begin; foo; rescue; bar; ensure; baz; end")
|
|
456
|
-
.must_be_parsed_as s(:ensure,
|
|
457
|
-
s(:rescue,
|
|
458
|
-
s(:call, nil, :foo),
|
|
459
|
-
s(:resbody,
|
|
460
|
-
s(:array),
|
|
461
|
-
s(:call, nil, :bar))),
|
|
462
|
-
s(:call, nil, :baz))
|
|
463
|
-
end
|
|
464
|
-
|
|
465
|
-
it "works with empty main and ensure bodies" do
|
|
466
|
-
_("begin; ensure; end")
|
|
467
|
-
.must_be_parsed_as s(:ensure, s(:nil))
|
|
468
|
-
end
|
|
469
|
-
end
|
|
470
|
-
|
|
471
|
-
describe "for the next statement" do
|
|
472
|
-
it "works with no arguments" do
|
|
473
|
-
_("foo do; next; end")
|
|
474
|
-
.must_be_parsed_as s(:iter,
|
|
475
|
-
s(:call, nil, :foo),
|
|
476
|
-
0,
|
|
477
|
-
s(:next))
|
|
478
|
-
end
|
|
479
|
-
|
|
480
|
-
it "works with one argument" do
|
|
481
|
-
_("foo do; next bar; end")
|
|
482
|
-
.must_be_parsed_as s(:iter,
|
|
483
|
-
s(:call, nil, :foo),
|
|
484
|
-
0,
|
|
485
|
-
s(:next, s(:call, nil, :bar)))
|
|
486
|
-
end
|
|
487
|
-
|
|
488
|
-
it "works with a splat argument" do
|
|
489
|
-
_("foo do; next *bar; end")
|
|
490
|
-
.must_be_parsed_as s(:iter,
|
|
491
|
-
s(:call, nil, :foo),
|
|
492
|
-
0,
|
|
493
|
-
s(:next,
|
|
494
|
-
s(:svalue,
|
|
495
|
-
s(:splat,
|
|
496
|
-
s(:call, nil, :bar)))))
|
|
497
|
-
end
|
|
498
|
-
|
|
499
|
-
it "works with several arguments" do
|
|
500
|
-
_("foo do; next bar, baz; end")
|
|
501
|
-
.must_be_parsed_as s(:iter,
|
|
502
|
-
s(:call, nil, :foo),
|
|
503
|
-
0,
|
|
504
|
-
s(:next,
|
|
505
|
-
s(:array,
|
|
506
|
-
s(:call, nil, :bar),
|
|
507
|
-
s(:call, nil, :baz))))
|
|
508
|
-
end
|
|
509
|
-
|
|
510
|
-
it "works with a function call with parentheses" do
|
|
511
|
-
_("foo do; next foo(bar); end")
|
|
512
|
-
.must_be_parsed_as s(:iter,
|
|
513
|
-
s(:call, nil, :foo),
|
|
514
|
-
0,
|
|
515
|
-
s(:next,
|
|
516
|
-
s(:call, nil, :foo,
|
|
517
|
-
s(:call, nil, :bar))))
|
|
518
|
-
end
|
|
519
|
-
|
|
520
|
-
it "works with a function call without parentheses" do
|
|
521
|
-
_("foo do; next foo bar; end")
|
|
522
|
-
.must_be_parsed_as s(:iter,
|
|
523
|
-
s(:call, nil, :foo),
|
|
524
|
-
0,
|
|
525
|
-
s(:next,
|
|
526
|
-
s(:call, nil, :foo,
|
|
527
|
-
s(:call, nil, :bar))))
|
|
528
|
-
end
|
|
529
|
-
end
|
|
530
|
-
|
|
531
|
-
describe "for the break statement" do
|
|
532
|
-
it "works with break with no arguments" do
|
|
533
|
-
_("foo do; break; end")
|
|
534
|
-
.must_be_parsed_as s(:iter,
|
|
535
|
-
s(:call, nil, :foo),
|
|
536
|
-
0,
|
|
537
|
-
s(:break))
|
|
538
|
-
end
|
|
539
|
-
|
|
540
|
-
it "works with break with one argument" do
|
|
541
|
-
_("foo do; break bar; end")
|
|
542
|
-
.must_be_parsed_as s(:iter,
|
|
543
|
-
s(:call, nil, :foo),
|
|
544
|
-
0,
|
|
545
|
-
s(:break, s(:call, nil, :bar)))
|
|
546
|
-
end
|
|
547
|
-
|
|
548
|
-
it "works with a splat argument" do
|
|
549
|
-
_("foo do; break *bar; end")
|
|
550
|
-
.must_be_parsed_as s(:iter,
|
|
551
|
-
s(:call, nil, :foo),
|
|
552
|
-
0,
|
|
553
|
-
s(:break,
|
|
554
|
-
s(:svalue,
|
|
555
|
-
s(:splat,
|
|
556
|
-
s(:call, nil, :bar)))))
|
|
557
|
-
end
|
|
558
|
-
|
|
559
|
-
it "works with break with several arguments" do
|
|
560
|
-
_("foo do; break bar, baz; end")
|
|
561
|
-
.must_be_parsed_as s(:iter,
|
|
562
|
-
s(:call, nil, :foo),
|
|
563
|
-
0,
|
|
564
|
-
s(:break,
|
|
565
|
-
s(:array,
|
|
566
|
-
s(:call, nil, :bar),
|
|
567
|
-
s(:call, nil, :baz))))
|
|
568
|
-
end
|
|
569
|
-
|
|
570
|
-
it "works with break with a function call with parentheses" do
|
|
571
|
-
_("foo do; break foo(bar); end")
|
|
572
|
-
.must_be_parsed_as s(:iter,
|
|
573
|
-
s(:call, nil, :foo),
|
|
574
|
-
0,
|
|
575
|
-
s(:break,
|
|
576
|
-
s(:call, nil, :foo,
|
|
577
|
-
s(:call, nil, :bar))))
|
|
578
|
-
end
|
|
579
|
-
|
|
580
|
-
it "works with break with a function call without parentheses" do
|
|
581
|
-
_("foo do; break foo bar; end")
|
|
582
|
-
.must_be_parsed_as s(:iter,
|
|
583
|
-
s(:call, nil, :foo),
|
|
584
|
-
0,
|
|
585
|
-
s(:break,
|
|
586
|
-
s(:call, nil, :foo,
|
|
587
|
-
s(:call, nil, :bar))))
|
|
588
|
-
end
|
|
589
|
-
end
|
|
590
|
-
|
|
591
|
-
describe "for lists of consecutive statments" do
|
|
592
|
-
it "removes extra blocks for grouped statements at the start of the list" do
|
|
593
|
-
_("(foo; bar); baz")
|
|
594
|
-
.must_be_parsed_as s(:block,
|
|
595
|
-
s(:call, nil, :foo),
|
|
596
|
-
s(:call, nil, :bar),
|
|
597
|
-
s(:call, nil, :baz))
|
|
598
|
-
end
|
|
599
|
-
|
|
600
|
-
it "keeps extra blocks for grouped statements at the end of the list" do
|
|
601
|
-
_("foo; (bar; baz)")
|
|
602
|
-
.must_be_parsed_as s(:block,
|
|
603
|
-
s(:call, nil, :foo),
|
|
604
|
-
s(:block,
|
|
605
|
-
s(:call, nil, :bar),
|
|
606
|
-
s(:call, nil, :baz)))
|
|
607
|
-
end
|
|
608
|
-
end
|
|
609
|
-
|
|
610
|
-
describe "for stabby lambda" do
|
|
611
|
-
it "works in the simple case" do
|
|
612
|
-
_("->(foo) { bar }")
|
|
613
|
-
.must_be_parsed_as s(:iter,
|
|
614
|
-
s(:lambda),
|
|
615
|
-
s(:args, :foo),
|
|
616
|
-
s(:call, nil, :bar))
|
|
617
|
-
end
|
|
618
|
-
|
|
619
|
-
it "works in the simple case without parentheses" do
|
|
620
|
-
_("-> foo { bar }")
|
|
621
|
-
.must_be_parsed_as s(:iter,
|
|
622
|
-
s(:lambda),
|
|
623
|
-
s(:args, :foo),
|
|
624
|
-
s(:call, nil, :bar))
|
|
625
|
-
end
|
|
626
|
-
|
|
627
|
-
it "works when there are zero arguments" do
|
|
628
|
-
_("->() { bar }")
|
|
629
|
-
.must_be_parsed_as s(:iter,
|
|
630
|
-
s(:lambda),
|
|
631
|
-
s(:args),
|
|
632
|
-
s(:call, nil, :bar))
|
|
633
|
-
end
|
|
634
|
-
|
|
635
|
-
it "works when there are no arguments" do
|
|
636
|
-
_("-> { bar }")
|
|
637
|
-
.must_be_parsed_as s(:iter,
|
|
638
|
-
s(:lambda),
|
|
639
|
-
0,
|
|
640
|
-
s(:call, nil, :bar))
|
|
641
|
-
end
|
|
642
|
-
|
|
643
|
-
it "works when there are no statements in the body" do
|
|
644
|
-
_("->(foo) { }")
|
|
645
|
-
.must_be_parsed_as s(:iter,
|
|
646
|
-
s(:lambda),
|
|
647
|
-
s(:args, :foo))
|
|
648
|
-
end
|
|
649
|
-
|
|
650
|
-
it "works when there are several statements in the body" do
|
|
651
|
-
_("->(foo) { bar; baz }")
|
|
652
|
-
.must_be_parsed_as s(:iter,
|
|
653
|
-
s(:lambda),
|
|
654
|
-
s(:args, :foo),
|
|
655
|
-
s(:block,
|
|
656
|
-
s(:call, nil, :bar),
|
|
657
|
-
s(:call, nil, :baz)))
|
|
658
|
-
end
|
|
659
|
-
end
|
|
660
|
-
|
|
661
|
-
describe "for lambda keyword" do
|
|
662
|
-
it "works in the simple case" do
|
|
663
|
-
_("lambda { |foo| bar }")
|
|
664
|
-
.must_be_parsed_as s(:iter,
|
|
665
|
-
s(:call, nil, :lambda),
|
|
666
|
-
s(:args, :foo),
|
|
667
|
-
s(:call, nil, :bar))
|
|
668
|
-
end
|
|
669
|
-
|
|
670
|
-
it "works with trailing argument comma" do
|
|
671
|
-
_("lambda { |foo,| bar }")
|
|
672
|
-
.must_be_parsed_as s(:iter,
|
|
673
|
-
s(:call, nil, :lambda),
|
|
674
|
-
s(:args, :foo, nil),
|
|
675
|
-
s(:call, nil, :bar))
|
|
676
|
-
end
|
|
677
|
-
end
|
|
678
|
-
end
|
|
679
|
-
end
|