ripper_ruby_parser 1.6.1 → 1.7.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.
Files changed (39) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +8 -0
  3. data/README.md +4 -23
  4. data/Rakefile +12 -12
  5. data/lib/ripper_ruby_parser.rb +2 -2
  6. data/lib/ripper_ruby_parser/commenting_ripper_parser.rb +9 -9
  7. data/lib/ripper_ruby_parser/parser.rb +3 -3
  8. data/lib/ripper_ruby_parser/sexp_handlers.rb +9 -9
  9. data/lib/ripper_ruby_parser/sexp_handlers/assignment.rb +3 -9
  10. data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb +19 -24
  11. data/lib/ripper_ruby_parser/sexp_handlers/literals.rb +14 -18
  12. data/lib/ripper_ruby_parser/sexp_handlers/methods.rb +3 -3
  13. data/lib/ripper_ruby_parser/sexp_processor.rb +4 -4
  14. data/lib/ripper_ruby_parser/unescape.rb +11 -11
  15. data/lib/ripper_ruby_parser/version.rb +1 -1
  16. data/test/end_to_end/comments_test.rb +10 -10
  17. data/test/end_to_end/comparison_test.rb +28 -28
  18. data/test/end_to_end/lib_comparison_test.rb +6 -6
  19. data/test/end_to_end/line_numbering_test.rb +10 -10
  20. data/test/end_to_end/samples_comparison_test.rb +5 -5
  21. data/test/end_to_end/test_comparison_test.rb +6 -6
  22. data/test/pt_testcase/pt_test.rb +7 -7
  23. data/test/ripper_ruby_parser/commenting_ripper_parser_test.rb +163 -169
  24. data/test/ripper_ruby_parser/parser_test.rb +338 -338
  25. data/test/ripper_ruby_parser/sexp_handlers/assignment_test.rb +475 -511
  26. data/test/ripper_ruby_parser/sexp_handlers/blocks_test.rb +582 -564
  27. data/test/ripper_ruby_parser/sexp_handlers/conditionals_test.rb +469 -469
  28. data/test/ripper_ruby_parser/sexp_handlers/literals_test.rb +713 -724
  29. data/test/ripper_ruby_parser/sexp_handlers/loops_test.rb +155 -155
  30. data/test/ripper_ruby_parser/sexp_handlers/method_calls_test.rb +181 -181
  31. data/test/ripper_ruby_parser/sexp_handlers/methods_test.rb +337 -352
  32. data/test/ripper_ruby_parser/sexp_handlers/operators_test.rb +298 -298
  33. data/test/ripper_ruby_parser/sexp_processor_test.rb +119 -119
  34. data/test/ripper_ruby_parser/version_test.rb +2 -2
  35. data/test/samples/lambdas.rb +5 -0
  36. data/test/samples/misc.rb +3 -0
  37. data/test/samples/strings.rb +7 -0
  38. data/test/test_helper.rb +8 -6
  39. metadata +12 -10
data/test/ripper_ruby_parser/sexp_handlers/operators_test.rb CHANGED
@@ -1,398 +1,398 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
3
+ require File.expand_path("../../test_helper.rb", File.dirname(__FILE__))
4
4
 
5
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,
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
95
  s(:call, nil, :foo),
96
96
  s(:or,
97
97
  s(:or, s(:call, nil, :bar), s(:call, nil, :baz)),
98
98
  s(:call, nil, :qux)))
99
99
  end
100
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))
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
106
  end
107
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))))
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
117
  end
118
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))))
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
128
  end
129
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))
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
136
  end
137
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))
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
144
  end
145
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)))
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
152
  end
153
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))
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
159
  end
160
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)))
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
166
  end
167
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))
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
174
  end
175
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))
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
182
  end
183
183
  end
184
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)
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
189
  end
190
190
 
191
- it 'handles negative number literals' do
192
- '-1..-2'.
193
- must_be_parsed_as s(:lit, -1..-2)
191
+ it "handles negative number literals" do
192
+ _("-1..-2")
193
+ .must_be_parsed_as s(:lit, -1..-2)
194
194
  end
195
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))
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
201
  end
202
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'))
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
208
  end
209
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))
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
215
  end
216
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))
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
222
  end
223
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))
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
229
  end
230
230
  end
231
231
 
232
- describe 'for the exclusive range operator' do
233
- it 'handles positive number literals' do
234
- '1...2'.
235
- must_be_parsed_as s(:lit, 1...2)
232
+ describe "for the exclusive range operator" do
233
+ it "handles positive number literals" do
234
+ _("1...2")
235
+ .must_be_parsed_as s(:lit, 1...2)
236
236
  end
237
237
 
238
- it 'handles negative number literals' do
239
- '-1...-2'.
240
- must_be_parsed_as s(:lit, -1...-2)
238
+ it "handles negative number literals" do
239
+ _("-1...-2")
240
+ .must_be_parsed_as s(:lit, -1...-2)
241
241
  end
242
242
 
243
- it 'handles float literals' do
244
- '1.0...2.0'.
245
- must_be_parsed_as s(:dot3,
246
- s(:lit, 1.0),
247
- s(:lit, 2.0))
243
+ it "handles float literals" do
244
+ _("1.0...2.0")
245
+ .must_be_parsed_as s(:dot3,
246
+ s(:lit, 1.0),
247
+ s(:lit, 2.0))
248
248
  end
249
249
 
250
- it 'handles string literals' do
251
- "'a'...'z'".
252
- must_be_parsed_as s(:dot3,
253
- s(:str, 'a'),
254
- s(:str, 'z'))
250
+ it "handles string literals" do
251
+ _("'a'...'z'")
252
+ .must_be_parsed_as s(:dot3,
253
+ s(:str, "a"),
254
+ s(:str, "z"))
255
255
  end
256
256
 
257
- it 'handles non-literal begin' do
258
- 'foo...3'.
259
- must_be_parsed_as s(:dot3,
260
- s(:call, nil, :foo),
261
- s(:lit, 3))
257
+ it "handles non-literal begin" do
258
+ _("foo...3")
259
+ .must_be_parsed_as s(:dot3,
260
+ s(:call, nil, :foo),
261
+ s(:lit, 3))
262
262
  end
263
263
 
264
- it 'handles non-literal end' do
265
- '3...foo'.
266
- must_be_parsed_as s(:dot3,
267
- s(:lit, 3),
268
- s(:call, nil, :foo))
264
+ it "handles non-literal end" do
265
+ _("3...foo")
266
+ .must_be_parsed_as s(:dot3,
267
+ s(:lit, 3),
268
+ s(:call, nil, :foo))
269
269
  end
270
270
 
271
- it 'handles two non-literals' do
272
- 'foo...bar'.
273
- must_be_parsed_as s(:dot3,
274
- s(:call, nil, :foo),
275
- s(:call, nil, :bar))
271
+ it "handles two non-literals" do
272
+ _("foo...bar")
273
+ .must_be_parsed_as s(:dot3,
274
+ s(:call, nil, :foo),
275
+ s(:call, nil, :bar))
276
276
  end
277
277
  end
278
278
 
279
- describe 'for unary operators' do
280
- it 'handles unary minus with an integer literal' do
281
- '- 1'.must_be_parsed_as s(:call, s(:lit, 1), :-@)
279
+ describe "for unary operators" do
280
+ it "handles unary minus with an integer literal" do
281
+ _("- 1").must_be_parsed_as s(:call, s(:lit, 1), :-@)
282
282
  end
283
283
 
284
- it 'handles unary minus with a float literal' do
285
- '- 3.14'.must_be_parsed_as s(:call, s(:lit, 3.14), :-@)
284
+ it "handles unary minus with a float literal" do
285
+ _("- 3.14").must_be_parsed_as s(:call, s(:lit, 3.14), :-@)
286
286
  end
287
287
 
288
- it 'handles unary minus with a non-literal' do
289
- '-foo'.
290
- must_be_parsed_as s(:call,
291
- s(:call, nil, :foo),
292
- :-@)
288
+ it "handles unary minus with a non-literal" do
289
+ _("-foo")
290
+ .must_be_parsed_as s(:call,
291
+ s(:call, nil, :foo),
292
+ :-@)
293
293
  end
294
294
 
295
- it 'handles unary minus with a negative number literal' do
296
- '- -1'.must_be_parsed_as s(:call, s(:lit, -1), :-@)
295
+ it "handles unary minus with a negative number literal" do
296
+ _("- -1").must_be_parsed_as s(:call, s(:lit, -1), :-@)
297
297
  end
298
298
 
299
- it 'handles unary plus with a number literal' do
300
- '+ 1'.must_be_parsed_as s(:call, s(:lit, 1), :+@)
299
+ it "handles unary plus with a number literal" do
300
+ _("+ 1").must_be_parsed_as s(:call, s(:lit, 1), :+@)
301
301
  end
302
302
 
303
- it 'handles unary plus with a non-literal' do
304
- '+foo'.
305
- must_be_parsed_as s(:call,
306
- s(:call, nil, :foo),
307
- :+@)
303
+ it "handles unary plus with a non-literal" do
304
+ _("+foo")
305
+ .must_be_parsed_as s(:call,
306
+ s(:call, nil, :foo),
307
+ :+@)
308
308
  end
309
309
 
310
- it 'handles unary !' do
311
- '!foo'.
312
- must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
310
+ it "handles unary !" do
311
+ _("!foo")
312
+ .must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
313
313
  end
314
314
 
315
- it 'converts :not to :!' do
316
- 'not foo'.
317
- must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
315
+ it "converts :not to :!" do
316
+ _("not foo")
317
+ .must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
318
318
  end
319
319
 
320
- it 'handles unary ! with a number literal' do
321
- '!1'.
322
- must_be_parsed_as s(:call, s(:lit, 1), :!)
320
+ it "handles unary ! with a number literal" do
321
+ _("!1")
322
+ .must_be_parsed_as s(:call, s(:lit, 1), :!)
323
323
  end
324
324
 
325
- it 'keeps :begin for the argument' do
326
- '- begin; foo; end'.
327
- must_be_parsed_as s(:call,
328
- s(:begin, s(:call, nil, :foo)),
329
- :-@)
325
+ it "keeps :begin for the argument" do
326
+ _("- begin; foo; end")
327
+ .must_be_parsed_as s(:call,
328
+ s(:begin, s(:call, nil, :foo)),
329
+ :-@)
330
330
  end
331
331
  end
332
332
 
333
- describe 'for the ternary operater' do
334
- it 'works in the simple case' do
335
- 'foo ? bar : baz'.
336
- must_be_parsed_as s(:if,
337
- s(:call, nil, :foo),
338
- s(:call, nil, :bar),
339
- s(:call, nil, :baz))
333
+ describe "for the ternary operater" do
334
+ it "works in the simple case" do
335
+ _("foo ? bar : baz")
336
+ .must_be_parsed_as s(:if,
337
+ s(:call, nil, :foo),
338
+ s(:call, nil, :bar),
339
+ s(:call, nil, :baz))
340
340
  end
341
341
 
342
- it 'keeps :begin for the first argument' do
343
- 'begin; foo; end ? bar : baz'.
344
- must_be_parsed_as s(:if,
345
- s(:begin, s(:call, nil, :foo)),
346
- s(:call, nil, :bar),
347
- s(:call, nil, :baz))
342
+ it "keeps :begin for the first argument" do
343
+ _("begin; foo; end ? bar : baz")
344
+ .must_be_parsed_as s(:if,
345
+ s(:begin, s(:call, nil, :foo)),
346
+ s(:call, nil, :bar),
347
+ s(:call, nil, :baz))
348
348
  end
349
349
 
350
- it 'keeps :begin for the second argument' do
351
- 'foo ? begin; bar; end : baz'.
352
- must_be_parsed_as s(:if,
353
- s(:call, nil, :foo),
354
- s(:begin, s(:call, nil, :bar)),
355
- s(:call, nil, :baz))
350
+ it "keeps :begin for the second argument" do
351
+ _("foo ? begin; bar; end : baz")
352
+ .must_be_parsed_as s(:if,
353
+ s(:call, nil, :foo),
354
+ s(:begin, s(:call, nil, :bar)),
355
+ s(:call, nil, :baz))
356
356
  end
357
357
 
358
- it 'keeps :begin for the third argument' do
359
- 'foo ? bar : begin; baz; end'.
360
- must_be_parsed_as s(:if,
361
- s(:call, nil, :foo),
362
- s(:call, nil, :bar),
363
- s(:begin, s(:call, nil, :baz)))
358
+ it "keeps :begin for the third argument" do
359
+ _("foo ? bar : begin; baz; end")
360
+ .must_be_parsed_as s(:if,
361
+ s(:call, nil, :foo),
362
+ s(:call, nil, :bar),
363
+ s(:begin, s(:call, nil, :baz)))
364
364
  end
365
365
  end
366
366
 
367
- describe 'for match operators' do
368
- it 'handles :=~ with two non-literals' do
369
- 'foo =~ bar'.
370
- must_be_parsed_as s(:call,
371
- s(:call, nil, :foo),
372
- :=~,
373
- s(:call, nil, :bar))
367
+ describe "for match operators" do
368
+ it "handles :=~ with two non-literals" do
369
+ _("foo =~ bar")
370
+ .must_be_parsed_as s(:call,
371
+ s(:call, nil, :foo),
372
+ :=~,
373
+ s(:call, nil, :bar))
374
374
  end
375
375
 
376
- it 'handles :=~ with literal regexp on the left hand side' do
377
- '/foo/ =~ bar'.
378
- must_be_parsed_as s(:match2,
379
- s(:lit, /foo/),
380
- s(:call, nil, :bar))
376
+ it "handles :=~ with literal regexp on the left hand side" do
377
+ _("/foo/ =~ bar")
378
+ .must_be_parsed_as s(:match2,
379
+ s(:lit, /foo/),
380
+ s(:call, nil, :bar))
381
381
  end
382
382
 
383
- it 'handles :=~ with literal regexp on the right hand side' do
384
- 'foo =~ /bar/'.
385
- must_be_parsed_as s(:match3,
386
- s(:lit, /bar/),
387
- s(:call, nil, :foo))
383
+ it "handles :=~ with literal regexp on the right hand side" do
384
+ _("foo =~ /bar/")
385
+ .must_be_parsed_as s(:match3,
386
+ s(:lit, /bar/),
387
+ s(:call, nil, :foo))
388
388
  end
389
389
 
390
- it 'handles negated match operators' do
391
- 'foo !~ bar'.must_be_parsed_as s(:not,
392
- s(:call,
393
- s(:call, nil, :foo),
394
- :=~,
395
- s(:call, nil, :bar)))
390
+ it "handles negated match operators" do
391
+ _("foo !~ bar").must_be_parsed_as s(:not,
392
+ s(:call,
393
+ s(:call, nil, :foo),
394
+ :=~,
395
+ s(:call, nil, :bar)))
396
396
  end
397
397
  end
398
398
  end