ripper_ruby_parser 1.7.2 → 1.8.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (45) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +28 -0
  3. data/README.md +4 -4
  4. data/lib/ripper_ruby_parser/commenting_ripper_parser.rb +24 -12
  5. data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb +33 -54
  6. data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb +17 -19
  7. data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb +34 -1
  8. data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb +1 -1
  9. data/lib/ripper_ruby_parser/sexp_handlers/methods.rb +12 -15
  10. data/lib/ripper_ruby_parser/sexp_handlers/string_literals.rb +21 -15
  11. data/lib/ripper_ruby_parser/sexp_processor.rb +4 -17
  12. data/lib/ripper_ruby_parser/unescape.rb +36 -12
  13. data/lib/ripper_ruby_parser/version.rb +1 -1
  14. metadata +110 -78
  15. data/Rakefile +0 -33
  16. data/test/end_to_end/comments_test.rb +0 -59
  17. data/test/end_to_end/comparison_test.rb +0 -104
  18. data/test/end_to_end/lib_comparison_test.rb +0 -18
  19. data/test/end_to_end/line_numbering_test.rb +0 -31
  20. data/test/end_to_end/samples_comparison_test.rb +0 -13
  21. data/test/end_to_end/test_comparison_test.rb +0 -18
  22. data/test/pt_testcase/pt_test.rb +0 -44
  23. data/test/ripper_ruby_parser/commenting_ripper_parser_test.rb +0 -200
  24. data/test/ripper_ruby_parser/parser_test.rb +0 -576
  25. data/test/ripper_ruby_parser/sexp_handlers/assignment_test.rb +0 -597
  26. data/test/ripper_ruby_parser/sexp_handlers/blocks_test.rb +0 -717
  27. data/test/ripper_ruby_parser/sexp_handlers/conditionals_test.rb +0 -536
  28. data/test/ripper_ruby_parser/sexp_handlers/literals_test.rb +0 -165
  29. data/test/ripper_ruby_parser/sexp_handlers/loops_test.rb +0 -209
  30. data/test/ripper_ruby_parser/sexp_handlers/method_calls_test.rb +0 -237
  31. data/test/ripper_ruby_parser/sexp_handlers/methods_test.rb +0 -429
  32. data/test/ripper_ruby_parser/sexp_handlers/operators_test.rb +0 -405
  33. data/test/ripper_ruby_parser/sexp_handlers/string_literals_test.rb +0 -973
  34. data/test/ripper_ruby_parser/sexp_processor_test.rb +0 -327
  35. data/test/ripper_ruby_parser/version_test.rb +0 -7
  36. data/test/samples/assignment.rb +0 -22
  37. data/test/samples/comments.rb +0 -13
  38. data/test/samples/conditionals.rb +0 -23
  39. data/test/samples/lambdas.rb +0 -5
  40. data/test/samples/loops.rb +0 -36
  41. data/test/samples/misc.rb +0 -285
  42. data/test/samples/number.rb +0 -9
  43. data/test/samples/operators.rb +0 -18
  44. data/test/samples/strings.rb +0 -147
  45. data/test/test_helper.rb +0 -111
data/test/ripper_ruby_parser/sexp_handlers/methods_test.rb DELETED
@@ -1,429 +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 instance method definitions" do
8
- it "treats kwrest argument as a local variable" do
9
- _("def foo(**bar); bar; end")
10
- .must_be_parsed_as s(:defn,
11
- :foo,
12
- s(:args, :"**bar"),
13
- s(:lvar, :bar))
14
- end
15
-
16
- it "treats kwrest argument as a local variable when other arguments are present" do
17
- _("def foo(bar, **baz); baz; end")
18
- .must_be_parsed_as s(:defn,
19
- :foo,
20
- s(:args, :bar, :"**baz"),
21
- s(:lvar, :baz))
22
- end
23
-
24
- it "treats kwrest argument as a local variable when an explicit block is present" do
25
- _("def foo(**bar, &baz); bar; end")
26
- .must_be_parsed_as s(:defn,
27
- :foo,
28
- s(:args, :"**bar", :"&baz"),
29
- s(:lvar, :bar))
30
- end
31
-
32
- it "treats block kwrest argument as an lvar" do
33
- _("def foo(**bar); baz { |**qux| bar; qux }; end")
34
- .must_be_parsed_as s(:defn, :foo,
35
- s(:args, :"**bar"),
36
- s(:iter,
37
- s(:call, nil, :baz),
38
- s(:args, :"**qux"),
39
- s(:block,
40
- s(:lvar, :bar),
41
- s(:lvar, :qux))))
42
- end
43
-
44
- it "works with a method argument with a default value" do
45
- _("def foo bar=nil; end")
46
- .must_be_parsed_as s(:defn,
47
- :foo,
48
- s(:args, s(:lasgn, :bar, s(:nil))),
49
- s(:nil))
50
- end
51
-
52
- it "works with several method arguments with default values" do
53
- _("def foo bar=1, baz=2; end")
54
- .must_be_parsed_as s(:defn,
55
- :foo,
56
- s(:args,
57
- s(:lasgn, :bar, s(:lit, 1)),
58
- s(:lasgn, :baz, s(:lit, 2))),
59
- s(:nil))
60
- end
61
-
62
- it "works with parentheses around the parameter list" do
63
- _("def foo(bar); end")
64
- .must_be_parsed_as s(:defn, :foo, s(:args, :bar), s(:nil))
65
- end
66
-
67
- it "works with a simple splat" do
68
- _("def foo *bar; end")
69
- .must_be_parsed_as s(:defn, :foo, s(:args, :"*bar"), s(:nil))
70
- end
71
-
72
- it "works with a regular argument plus splat" do
73
- _("def foo bar, *baz; end")
74
- .must_be_parsed_as s(:defn, :foo, s(:args, :bar, :"*baz"), s(:nil))
75
- end
76
-
77
- it "works with a nameless splat" do
78
- _("def foo *; end")
79
- .must_be_parsed_as s(:defn,
80
- :foo,
81
- s(:args, :"*"),
82
- s(:nil))
83
- end
84
-
85
- it "works with a nameless kwrest argument" do
86
- _("def foo **; end")
87
- .must_be_parsed_as s(:defn,
88
- :foo,
89
- s(:args, :"**"),
90
- s(:nil))
91
- end
92
-
93
- it "works for a simple case with explicit block parameter" do
94
- _("def foo &bar; end")
95
- .must_be_parsed_as s(:defn,
96
- :foo,
97
- s(:args, :"&bar"),
98
- s(:nil))
99
- end
100
-
101
- it "works with a regular argument plus explicit block parameter" do
102
- _("def foo bar, &baz; end")
103
- .must_be_parsed_as s(:defn,
104
- :foo,
105
- s(:args, :bar, :"&baz"),
106
- s(:nil))
107
- end
108
-
109
- it "works with a default value plus explicit block parameter" do
110
- _("def foo bar=1, &baz; end")
111
- .must_be_parsed_as s(:defn,
112
- :foo,
113
- s(:args,
114
- s(:lasgn, :bar, s(:lit, 1)),
115
- :"&baz"),
116
- s(:nil))
117
- end
118
-
119
- it "works with a default value plus mandatory argument" do
120
- _("def foo bar=1, baz; end")
121
- .must_be_parsed_as s(:defn,
122
- :foo,
123
- s(:args,
124
- s(:lasgn, :bar, s(:lit, 1)),
125
- :baz),
126
- s(:nil))
127
- end
128
-
129
- it "works with a splat plus explicit block parameter" do
130
- _("def foo *bar, &baz; end")
131
- .must_be_parsed_as s(:defn,
132
- :foo,
133
- s(:args, :"*bar", :"&baz"),
134
- s(:nil))
135
- end
136
-
137
- it "works with a default value plus splat" do
138
- _("def foo bar=1, *baz; end")
139
- .must_be_parsed_as s(:defn,
140
- :foo,
141
- s(:args,
142
- s(:lasgn, :bar, s(:lit, 1)),
143
- :"*baz"),
144
- s(:nil))
145
- end
146
-
147
- it "works with a default value, splat, plus final mandatory arguments" do
148
- _("def foo bar=1, *baz, qux, quuz; end")
149
- .must_be_parsed_as s(:defn,
150
- :foo,
151
- s(:args,
152
- s(:lasgn, :bar, s(:lit, 1)),
153
- :"*baz", :qux, :quuz),
154
- s(:nil))
155
- end
156
-
157
- it "works with a named argument with a default value" do
158
- _("def foo bar: 1; end")
159
- .must_be_parsed_as s(:defn,
160
- :foo,
161
- s(:args,
162
- s(:kwarg, :bar, s(:lit, 1))),
163
- s(:nil))
164
- end
165
-
166
- it "works with a named argument with no default value" do
167
- _("def foo bar:; end")
168
- .must_be_parsed_as s(:defn,
169
- :foo,
170
- s(:args,
171
- s(:kwarg, :bar)),
172
- s(:nil))
173
- end
174
-
175
- it "works with a double splat" do
176
- _("def foo **bar; end")
177
- .must_be_parsed_as s(:defn,
178
- :foo,
179
- s(:args, :'**bar'),
180
- s(:nil))
181
- end
182
-
183
- it "works with argument destructuring" do
184
- _("def foo((bar, baz)); end")
185
- .must_be_parsed_as s(:defn, :foo,
186
- s(:args, s(:masgn, :bar, :baz)),
187
- s(:nil))
188
- end
189
-
190
- it "works with argument destructuring including splat" do
191
- _("def foo((bar, *baz)); end")
192
- .must_be_parsed_as s(:defn, :foo,
193
- s(:args, s(:masgn, :bar, :'*baz')),
194
- s(:nil))
195
- end
196
-
197
- it "works with nested argument destructuring" do
198
- _("def foo((bar, (baz, qux))); end")
199
- .must_be_parsed_as s(:defn, :foo,
200
- s(:args, s(:masgn, :bar, s(:masgn, :baz, :qux))),
201
- s(:nil))
202
- end
203
-
204
- it "works when the method name is an operator" do
205
- _("def +; end")
206
- .must_be_parsed_as s(:defn, :+, s(:args),
207
- s(:nil))
208
- end
209
-
210
- it "works when the method name is a keyword" do
211
- _("def for; end")
212
- .must_be_parsed_as s(:defn, :for, s(:args),
213
- s(:nil))
214
- end
215
-
216
- it "assigns correct line numbers when the body is empty" do
217
- _("def bar\nend")
218
- .must_be_parsed_as s(:defn,
219
- :bar,
220
- s(:args).line(1),
221
- s(:nil).line(2)).line(1),
222
- with_line_numbers: true
223
- end
224
- end
225
-
226
- describe "for singleton method definitions" do
227
- it "works with empty body" do
228
- _("def foo.bar; end")
229
- .must_be_parsed_as s(:defs,
230
- s(:call, nil, :foo),
231
- :bar,
232
- s(:args),
233
- s(:nil))
234
- end
235
-
236
- it "works with a body with multiple statements" do
237
- _("def foo.bar; baz; qux; end")
238
- .must_be_parsed_as s(:defs,
239
- s(:call, nil, :foo),
240
- :bar,
241
- s(:args),
242
- s(:call, nil, :baz),
243
- s(:call, nil, :qux))
244
- end
245
-
246
- it "works with a simple splat" do
247
- _("def foo.bar *baz; end")
248
- .must_be_parsed_as s(:defs,
249
- s(:call, nil, :foo),
250
- :bar,
251
- s(:args, :"*baz"),
252
- s(:nil))
253
- end
254
-
255
- it "works when the method name is a keyword" do
256
- _("def foo.for; end")
257
- .must_be_parsed_as s(:defs,
258
- s(:call, nil, :foo),
259
- :for, s(:args),
260
- s(:nil))
261
- end
262
- end
263
-
264
- describe "for the alias statement" do
265
- it "works with regular barewords" do
266
- _("alias foo bar")
267
- .must_be_parsed_as s(:alias,
268
- s(:lit, :foo), s(:lit, :bar))
269
- end
270
-
271
- it "works with symbols" do
272
- _("alias :foo :bar")
273
- .must_be_parsed_as s(:alias,
274
- s(:lit, :foo), s(:lit, :bar))
275
- end
276
-
277
- it "works with operator barewords" do
278
- _("alias + -")
279
- .must_be_parsed_as s(:alias,
280
- s(:lit, :+), s(:lit, :-))
281
- end
282
-
283
- it "treats keywords as symbols" do
284
- _("alias next foo")
285
- .must_be_parsed_as s(:alias, s(:lit, :next), s(:lit, :foo))
286
- end
287
-
288
- it "works with global variables" do
289
- _("alias $foo $bar")
290
- .must_be_parsed_as s(:valias, :$foo, :$bar)
291
- end
292
- end
293
-
294
- describe "for the undef statement" do
295
- it "works with a single bareword identifier" do
296
- _("undef foo")
297
- .must_be_parsed_as s(:undef, s(:lit, :foo))
298
- end
299
-
300
- it "works with a single symbol" do
301
- _("undef :foo")
302
- .must_be_parsed_as s(:undef, s(:lit, :foo))
303
- end
304
-
305
- it "works with multiple bareword identifiers" do
306
- _("undef foo, bar")
307
- .must_be_parsed_as s(:block,
308
- s(:undef, s(:lit, :foo)),
309
- s(:undef, s(:lit, :bar)))
310
- end
311
-
312
- it "works with multiple bareword symbols" do
313
- _("undef :foo, :bar")
314
- .must_be_parsed_as s(:block,
315
- s(:undef, s(:lit, :foo)),
316
- s(:undef, s(:lit, :bar)))
317
- end
318
- end
319
-
320
- describe "for the return statement" do
321
- it "works with no arguments" do
322
- _("return")
323
- .must_be_parsed_as s(:return)
324
- end
325
-
326
- it "works with one argument" do
327
- _("return foo")
328
- .must_be_parsed_as s(:return,
329
- s(:call, nil, :foo))
330
- end
331
-
332
- it "works with a splat argument" do
333
- _("return *foo")
334
- .must_be_parsed_as s(:return,
335
- s(:svalue,
336
- s(:splat,
337
- s(:call, nil, :foo))))
338
- end
339
-
340
- it "works with multiple arguments" do
341
- _("return foo, bar")
342
- .must_be_parsed_as s(:return,
343
- s(:array,
344
- s(:call, nil, :foo),
345
- s(:call, nil, :bar)))
346
- end
347
-
348
- it "works with a regular argument and a splat argument" do
349
- _("return foo, *bar")
350
- .must_be_parsed_as s(:return,
351
- s(:array,
352
- s(:call, nil, :foo),
353
- s(:splat,
354
- s(:call, nil, :bar))))
355
- end
356
-
357
- it "works with a function call with parentheses" do
358
- _("return foo(bar)")
359
- .must_be_parsed_as s(:return,
360
- s(:call, nil, :foo,
361
- s(:call, nil, :bar)))
362
- end
363
-
364
- it "works with a function call without parentheses" do
365
- _("return foo bar")
366
- .must_be_parsed_as s(:return,
367
- s(:call, nil, :foo,
368
- s(:call, nil, :bar)))
369
- end
370
- end
371
-
372
- describe "for yield" do
373
- it "works with no arguments and no parentheses" do
374
- _("yield")
375
- .must_be_parsed_as s(:yield)
376
- end
377
-
378
- it "works with parentheses but no arguments" do
379
- _("yield()")
380
- .must_be_parsed_as s(:yield)
381
- end
382
-
383
- it "works with one argument and no parentheses" do
384
- _("yield foo")
385
- .must_be_parsed_as s(:yield, s(:call, nil, :foo))
386
- end
387
-
388
- it "works with one argument and parentheses" do
389
- _("yield(foo)")
390
- .must_be_parsed_as s(:yield, s(:call, nil, :foo))
391
- end
392
-
393
- it "works with multiple arguments and no parentheses" do
394
- _("yield foo, bar")
395
- .must_be_parsed_as s(:yield,
396
- s(:call, nil, :foo),
397
- s(:call, nil, :bar))
398
- end
399
-
400
- it "works with multiple arguments and parentheses" do
401
- _("yield(foo, bar)")
402
- .must_be_parsed_as s(:yield,
403
- s(:call, nil, :foo),
404
- s(:call, nil, :bar))
405
- end
406
-
407
- it "works with splat" do
408
- _("yield foo, *bar")
409
- .must_be_parsed_as s(:yield,
410
- s(:call, nil, :foo),
411
- s(:splat, s(:call, nil, :bar)))
412
- end
413
-
414
- it "works with a function call with parentheses" do
415
- _("yield foo(bar)")
416
- .must_be_parsed_as s(:yield,
417
- s(:call, nil, :foo,
418
- s(:call, nil, :bar)))
419
- end
420
-
421
- it "works with a function call without parentheses" do
422
- _("yield foo bar")
423
- .must_be_parsed_as s(:yield,
424
- s(:call, nil, :foo,
425
- s(:call, nil, :bar)))
426
- end
427
- end
428
- end
429
- end
data/test/ripper_ruby_parser/sexp_handlers/operators_test.rb DELETED
@@ -1,405 +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 boolean operators" do
8
- it "handles :and" do
9
- _("foo and bar")
10
- .must_be_parsed_as s(:and,
11
- s(:call, nil, :foo),
12
- s(:call, nil, :bar))
13
- end
14
-
15
- it "handles double :and" do
16
- _("foo and bar and baz")
17
- .must_be_parsed_as s(:and,
18
- s(:call, nil, :foo),
19
- s(:and,
20
- s(:call, nil, :bar),
21
- s(:call, nil, :baz)))
22
- end
23
-
24
- it "handles :or" do
25
- _("foo or bar")
26
- .must_be_parsed_as s(:or,
27
- s(:call, nil, :foo),
28
- s(:call, nil, :bar))
29
- end
30
-
31
- it "handles double :or" do
32
- _("foo or bar or baz")
33
- .must_be_parsed_as s(:or,
34
- s(:call, nil, :foo),
35
- s(:or,
36
- s(:call, nil, :bar),
37
- s(:call, nil, :baz)))
38
- end
39
-
40
- it "handles :or after :and" do
41
- _("foo and bar or baz")
42
- .must_be_parsed_as s(:or,
43
- s(:and,
44
- s(:call, nil, :foo),
45
- s(:call, nil, :bar)),
46
- s(:call, nil, :baz))
47
- end
48
-
49
- it "handles :and after :or" do
50
- _("foo or bar and baz")
51
- .must_be_parsed_as s(:and,
52
- s(:or,
53
- s(:call, nil, :foo),
54
- s(:call, nil, :bar)),
55
- s(:call, nil, :baz))
56
- end
57
-
58
- it "converts :&& to :and" do
59
- _("foo && bar")
60
- .must_be_parsed_as s(:and,
61
- s(:call, nil, :foo),
62
- s(:call, nil, :bar))
63
- end
64
-
65
- it "handles :|| after :&&" do
66
- _("foo && bar || baz")
67
- .must_be_parsed_as s(:or,
68
- s(:and,
69
- s(:call, nil, :foo),
70
- s(:call, nil, :bar)),
71
- s(:call, nil, :baz))
72
- end
73
-
74
- it "handles :&& after :||" do
75
- _("foo || bar && baz")
76
- .must_be_parsed_as s(:or,
77
- s(:call, nil, :foo),
78
- s(:and,
79
- s(:call, nil, :bar),
80
- s(:call, nil, :baz)))
81
- end
82
-
83
- it "handles :|| with parentheses" do
84
- _("(foo || bar) || baz")
85
- .must_be_parsed_as s(:or,
86
- s(:or,
87
- s(:call, nil, :foo),
88
- s(:call, nil, :bar)),
89
- s(:call, nil, :baz))
90
- end
91
-
92
- it "handles nested :|| with parentheses" do
93
- _("foo || (bar || baz) || qux")
94
- .must_be_parsed_as s(:or,
95
- s(:call, nil, :foo),
96
- s(:or,
97
- s(:or, s(:call, nil, :bar), s(:call, nil, :baz)),
98
- s(:call, nil, :qux)))
99
- end
100
-
101
- it "converts :|| to :or" do
102
- _("foo || bar")
103
- .must_be_parsed_as s(:or,
104
- s(:call, nil, :foo),
105
- s(:call, nil, :bar))
106
- end
107
-
108
- it "handles triple :and" do
109
- _("foo and bar and baz and qux")
110
- .must_be_parsed_as s(:and,
111
- s(:call, nil, :foo),
112
- s(:and,
113
- s(:call, nil, :bar),
114
- s(:and,
115
- s(:call, nil, :baz),
116
- s(:call, nil, :qux))))
117
- end
118
-
119
- it "handles triple :&&" do
120
- _("foo && bar && baz && qux")
121
- .must_be_parsed_as s(:and,
122
- s(:call, nil, :foo),
123
- s(:and,
124
- s(:call, nil, :bar),
125
- s(:and,
126
- s(:call, nil, :baz),
127
- s(:call, nil, :qux))))
128
- end
129
-
130
- it "handles :!=" do
131
- _("foo != bar")
132
- .must_be_parsed_as s(:call,
133
- s(:call, nil, :foo),
134
- :!=,
135
- s(:call, nil, :bar))
136
- end
137
-
138
- it "keeps :begin for the first argument of a binary operator" do
139
- _("begin; bar; end + foo")
140
- .must_be_parsed_as s(:call,
141
- s(:begin, s(:call, nil, :bar)),
142
- :+,
143
- s(:call, nil, :foo))
144
- end
145
-
146
- it "keeps :begin for the second argument of a binary operator" do
147
- _("foo + begin; bar; end")
148
- .must_be_parsed_as s(:call,
149
- s(:call, nil, :foo),
150
- :+,
151
- s(:begin, s(:call, nil, :bar)))
152
- end
153
-
154
- it "does not keep :begin for the first argument of a boolean operator" do
155
- _("begin; bar; end and foo")
156
- .must_be_parsed_as s(:and,
157
- s(:call, nil, :bar),
158
- s(:call, nil, :foo))
159
- end
160
-
161
- it "keeps :begin for the second argument of a boolean operator" do
162
- _("foo and begin; bar; end")
163
- .must_be_parsed_as s(:and,
164
- s(:call, nil, :foo),
165
- s(:begin, s(:call, nil, :bar)))
166
- end
167
-
168
- it "does not keep :begin for the first argument of a shift operator" do
169
- _("begin; bar; end << foo")
170
- .must_be_parsed_as s(:call,
171
- s(:call, nil, :bar),
172
- :<<,
173
- s(:call, nil, :foo))
174
- end
175
-
176
- it "does not keep :begin for the second argument of a shift operator" do
177
- _("foo >> begin; bar; end")
178
- .must_be_parsed_as s(:call,
179
- s(:call, nil, :foo),
180
- :>>,
181
- s(:call, nil, :bar))
182
- end
183
- end
184
-
185
- describe "for the range operator" do
186
- it "handles positive number literals" do
187
- _("1..2")
188
- .must_be_parsed_as s(:lit, 1..2)
189
- end
190
-
191
- it "handles negative number literals" do
192
- _("-1..-2")
193
- .must_be_parsed_as s(:lit, -1..-2)
194
- end
195
-
196
- it "handles float literals" do
197
- _("1.0..2.0")
198
- .must_be_parsed_as s(:dot2,
199
- s(:lit, 1.0),
200
- s(:lit, 2.0))
201
- end
202
-
203
- it "handles string literals" do
204
- _("'a'..'z'")
205
- .must_be_parsed_as s(:dot2,
206
- s(:str, "a"),
207
- s(:str, "z"))
208
- end
209
-
210
- it "handles non-literal begin" do
211
- _("foo..3")
212
- .must_be_parsed_as s(:dot2,
213
- s(:call, nil, :foo),
214
- s(:lit, 3))
215
- end
216
-
217
- it "handles non-literal end" do
218
- _("3..foo")
219
- .must_be_parsed_as s(:dot2,
220
- s(:lit, 3),
221
- s(:call, nil, :foo))
222
- end
223
-
224
- it "handles non-literals" do
225
- _("foo..bar")
226
- .must_be_parsed_as s(:dot2,
227
- s(:call, nil, :foo),
228
- s(:call, nil, :bar))
229
- end
230
-
231
- it "handles endless range literals" do
232
- skip "This Ruby version does not support endless ranges" if RUBY_VERSION < "2.6.0"
233
- _("1..")
234
- .must_be_parsed_as s(:dot2, s(:lit, 1), nil)
235
- end
236
- end
237
-
238
- describe "for the exclusive range operator" do
239
- it "handles positive number literals" do
240
- _("1...2")
241
- .must_be_parsed_as s(:lit, 1...2)
242
- end
243
-
244
- it "handles negative number literals" do
245
- _("-1...-2")
246
- .must_be_parsed_as s(:lit, -1...-2)
247
- end
248
-
249
- it "handles float literals" do
250
- _("1.0...2.0")
251
- .must_be_parsed_as s(:dot3,
252
- s(:lit, 1.0),
253
- s(:lit, 2.0))
254
- end
255
-
256
- it "handles string literals" do
257
- _("'a'...'z'")
258
- .must_be_parsed_as s(:dot3,
259
- s(:str, "a"),
260
- s(:str, "z"))
261
- end
262
-
263
- it "handles non-literal begin" do
264
- _("foo...3")
265
- .must_be_parsed_as s(:dot3,
266
- s(:call, nil, :foo),
267
- s(:lit, 3))
268
- end
269
-
270
- it "handles non-literal end" do
271
- _("3...foo")
272
- .must_be_parsed_as s(:dot3,
273
- s(:lit, 3),
274
- s(:call, nil, :foo))
275
- end
276
-
277
- it "handles two non-literals" do
278
- _("foo...bar")
279
- .must_be_parsed_as s(:dot3,
280
- s(:call, nil, :foo),
281
- s(:call, nil, :bar))
282
- end
283
- end
284
-
285
- describe "for unary operators" do
286
- it "handles unary minus with an integer literal" do
287
- _("- 1").must_be_parsed_as s(:call, s(:lit, 1), :-@)
288
- end
289
-
290
- it "handles unary minus with a float literal" do
291
- _("- 3.14").must_be_parsed_as s(:call, s(:lit, 3.14), :-@)
292
- end
293
-
294
- it "handles unary minus with a non-literal" do
295
- _("-foo")
296
- .must_be_parsed_as s(:call,
297
- s(:call, nil, :foo),
298
- :-@)
299
- end
300
-
301
- it "handles unary minus with a negative number literal" do
302
- _("- -1").must_be_parsed_as s(:call, s(:lit, -1), :-@)
303
- end
304
-
305
- it "handles unary plus with a number literal" do
306
- _("+ 1").must_be_parsed_as s(:call, s(:lit, 1), :+@)
307
- end
308
-
309
- it "handles unary plus with a non-literal" do
310
- _("+foo")
311
- .must_be_parsed_as s(:call,
312
- s(:call, nil, :foo),
313
- :+@)
314
- end
315
-
316
- it "handles unary !" do
317
- _("!foo")
318
- .must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
319
- end
320
-
321
- it "converts :not to :!" do
322
- _("not foo")
323
- .must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
324
- end
325
-
326
- it "handles unary ! with a number literal" do
327
- _("!1")
328
- .must_be_parsed_as s(:call, s(:lit, 1), :!)
329
- end
330
-
331
- it "keeps :begin for the argument" do
332
- _("- begin; foo; end")
333
- .must_be_parsed_as s(:call,
334
- s(:begin, s(:call, nil, :foo)),
335
- :-@)
336
- end
337
- end
338
-
339
- describe "for the ternary operater" do
340
- it "works in the simple case" do
341
- _("foo ? bar : baz")
342
- .must_be_parsed_as s(:if,
343
- s(:call, nil, :foo),
344
- s(:call, nil, :bar),
345
- s(:call, nil, :baz))
346
- end
347
-
348
- it "keeps :begin for the first argument" do
349
- _("begin; foo; end ? bar : baz")
350
- .must_be_parsed_as s(:if,
351
- s(:begin, s(:call, nil, :foo)),
352
- s(:call, nil, :bar),
353
- s(:call, nil, :baz))
354
- end
355
-
356
- it "keeps :begin for the second argument" do
357
- _("foo ? begin; bar; end : baz")
358
- .must_be_parsed_as s(:if,
359
- s(:call, nil, :foo),
360
- s(:begin, s(:call, nil, :bar)),
361
- s(:call, nil, :baz))
362
- end
363
-
364
- it "keeps :begin for the third argument" do
365
- _("foo ? bar : begin; baz; end")
366
- .must_be_parsed_as s(:if,
367
- s(:call, nil, :foo),
368
- s(:call, nil, :bar),
369
- s(:begin, s(:call, nil, :baz)))
370
- end
371
- end
372
-
373
- describe "for match operators" do
374
- it "handles :=~ with two non-literals" do
375
- _("foo =~ bar")
376
- .must_be_parsed_as s(:call,
377
- s(:call, nil, :foo),
378
- :=~,
379
- s(:call, nil, :bar))
380
- end
381
-
382
- it "handles :=~ with literal regexp on the left hand side" do
383
- _("/foo/ =~ bar")
384
- .must_be_parsed_as s(:match2,
385
- s(:lit, /foo/),
386
- s(:call, nil, :bar))
387
- end
388
-
389
- it "handles :=~ with literal regexp on the right hand side" do
390
- _("foo =~ /bar/")
391
- .must_be_parsed_as s(:match3,
392
- s(:lit, /bar/),
393
- s(:call, nil, :foo))
394
- end
395
-
396
- it "handles negated match operators" do
397
- _("foo !~ bar").must_be_parsed_as s(:not,
398
- s(:call,
399
- s(:call, nil, :foo),
400
- :=~,
401
- s(:call, nil, :bar)))
402
- end
403
- end
404
- end
405
- end