ripper_ruby_parser 1.6.1 → 1.7.0

Sign up to get free protection for your applications and to get access to all the features.
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/assignment_test.rb CHANGED
@@ -1,191 +1,192 @@
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
6
  let(:parser) { RipperRubyParser::Parser.new }
7
7
 
8
- describe '#parse' do
9
- describe 'for single assignment' do
10
- it 'works when assigning to a namespaced constant' do
11
- 'Foo::Bar = baz'.
12
- must_be_parsed_as s(:cdecl,
13
- s(:colon2, s(:const, :Foo), :Bar),
14
- s(:call, nil, :baz))
8
+ describe "#parse" do
9
+ describe "for single assignment" do
10
+ it "works when assigning to a namespaced constant" do
11
+ _("Foo::Bar = baz")
12
+ .must_be_parsed_as s(:cdecl,
13
+ s(:colon2, s(:const, :Foo), :Bar),
14
+ s(:call, nil, :baz))
15
15
  end
16
16
 
17
- it 'works when assigning to constant in the root namespace' do
18
- '::Foo = bar'.
19
- must_be_parsed_as s(:cdecl,
20
- s(:colon3, :Foo),
21
- s(:call, nil, :bar))
17
+ it "works when assigning to constant in the root namespace" do
18
+ _("::Foo = bar")
19
+ .must_be_parsed_as s(:cdecl,
20
+ s(:colon3, :Foo),
21
+ s(:call, nil, :bar))
22
22
  end
23
23
 
24
- it 'works with blocks' do
25
- 'foo = begin; bar; end'.
26
- must_be_parsed_as s(:lasgn, :foo, s(:call, nil, :bar))
24
+ it "works with blocks" do
25
+ _("foo = begin; bar; end")
26
+ .must_be_parsed_as s(:lasgn, :foo, s(:call, nil, :bar))
27
27
  end
28
28
 
29
- describe 'with a right-hand splat' do
30
- it 'works in the simple case' do
31
- 'foo = *bar'.
32
- must_be_parsed_as s(:lasgn, :foo,
33
- s(:svalue,
34
- s(:splat,
35
- s(:call, nil, :bar))))
29
+ describe "with a right-hand splat" do
30
+ it "works in the simple case" do
31
+ _("foo = *bar")
32
+ .must_be_parsed_as s(:lasgn, :foo,
33
+ s(:svalue,
34
+ s(:splat,
35
+ s(:call, nil, :bar))))
36
36
  end
37
37
 
38
- it 'works with blocks' do
39
- 'foo = *begin; bar; end'.
40
- must_be_parsed_as s(:lasgn, :foo,
41
- s(:svalue, s(:splat, s(:call, nil, :bar))))
38
+ it "works with blocks" do
39
+ _("foo = *begin; bar; end")
40
+ .must_be_parsed_as s(:lasgn, :foo,
41
+ s(:svalue, s(:splat, s(:call, nil, :bar))))
42
42
  end
43
43
  end
44
44
 
45
- describe 'with several items on the right hand side' do
46
- it 'works in the simple case' do
47
- 'foo = bar, baz'.
48
- must_be_parsed_as s(:lasgn, :foo,
49
- s(:svalue,
50
- s(:array,
51
- s(:call, nil, :bar),
52
- s(:call, nil, :baz))))
45
+ describe "with several items on the right hand side" do
46
+ it "works in the simple case" do
47
+ _("foo = bar, baz")
48
+ .must_be_parsed_as s(:lasgn, :foo,
49
+ s(:svalue,
50
+ s(:array,
51
+ s(:call, nil, :bar),
52
+ s(:call, nil, :baz))))
53
53
  end
54
54
 
55
- it 'works with a splat' do
56
- 'foo = bar, *baz'.
57
- must_be_parsed_as s(:lasgn, :foo,
58
- s(:svalue,
59
- s(:array,
60
- s(:call, nil, :bar),
61
- s(:splat,
62
- s(:call, nil, :baz)))))
55
+ it "works with a splat" do
56
+ _("foo = bar, *baz")
57
+ .must_be_parsed_as s(:lasgn, :foo,
58
+ s(:svalue,
59
+ s(:array,
60
+ s(:call, nil, :bar),
61
+ s(:splat,
62
+ s(:call, nil, :baz)))))
63
63
  end
64
64
  end
65
65
 
66
- describe 'with an array literal on the right hand side' do
66
+ describe "with an array literal on the right hand side" do
67
67
  specify do
68
- 'foo = [bar, baz]'.
69
- must_be_parsed_as s(:lasgn, :foo,
70
- s(:array,
71
- s(:call, nil, :bar),
72
- s(:call, nil, :baz)))
68
+ _("foo = [bar, baz]")
69
+ .must_be_parsed_as s(:lasgn, :foo,
70
+ s(:array,
71
+ s(:call, nil, :bar),
72
+ s(:call, nil, :baz)))
73
73
  end
74
74
  end
75
75
 
76
- it 'works when assigning to an instance variable' do
77
- '@foo = bar'.
78
- must_be_parsed_as s(:iasgn,
79
- :@foo,
80
- s(:call, nil, :bar))
76
+ it "works when assigning to an instance variable" do
77
+ _("@foo = bar")
78
+ .must_be_parsed_as s(:iasgn,
79
+ :@foo,
80
+ s(:call, nil, :bar))
81
81
  end
82
82
 
83
- it 'works when assigning to a constant' do
84
- 'FOO = bar'.
85
- must_be_parsed_as s(:cdecl,
86
- :FOO,
87
- s(:call, nil, :bar))
83
+ it "works when assigning to a constant" do
84
+ _("FOO = bar")
85
+ .must_be_parsed_as s(:cdecl,
86
+ :FOO,
87
+ s(:call, nil, :bar))
88
88
  end
89
89
 
90
- it 'works when assigning to a collection element' do
91
- 'foo[bar] = baz'.
92
- must_be_parsed_as s(:attrasgn,
93
- s(:call, nil, :foo),
94
- :[]=,
95
- s(:call, nil, :bar),
96
- s(:call, nil, :baz))
90
+ it "works when assigning to a collection element" do
91
+ _("foo[bar] = baz")
92
+ .must_be_parsed_as s(:attrasgn,
93
+ s(:call, nil, :foo),
94
+ :[]=,
95
+ s(:call, nil, :bar),
96
+ s(:call, nil, :baz))
97
97
  end
98
98
 
99
- it 'works when assigning to an attribute' do
100
- 'foo.bar = baz'.
101
- must_be_parsed_as s(:attrasgn,
102
- s(:call, nil, :foo),
103
- :bar=,
104
- s(:call, nil, :baz))
99
+ it "works when assigning to an attribute" do
100
+ _("foo.bar = baz")
101
+ .must_be_parsed_as s(:attrasgn,
102
+ s(:call, nil, :foo),
103
+ :bar=,
104
+ s(:call, nil, :baz))
105
105
  end
106
106
 
107
- describe 'when assigning to a class variable' do
108
- it 'works outside a method' do
109
- '@@foo = bar'.
110
- must_be_parsed_as s(:cvdecl,
111
- :@@foo,
112
- s(:call, nil, :bar))
107
+ describe "when assigning to a class variable" do
108
+ it "works outside a method" do
109
+ _("@@foo = bar")
110
+ .must_be_parsed_as s(:cvdecl,
111
+ :@@foo,
112
+ s(:call, nil, :bar))
113
113
  end
114
114
 
115
- it 'works inside a method' do
116
- 'def foo; @@bar = baz; end'.
117
- must_be_parsed_as s(:defn,
118
- :foo, s(:args),
119
- s(:cvasgn, :@@bar, s(:call, nil, :baz)))
115
+ it "works inside a method" do
116
+ _("def foo; @@bar = baz; end")
117
+ .must_be_parsed_as s(:defn,
118
+ :foo, s(:args),
119
+ s(:cvasgn, :@@bar, s(:call, nil, :baz)))
120
120
  end
121
121
 
122
- it 'works inside a method with a receiver' do
123
- 'def self.foo; @@bar = baz; end'.
124
- must_be_parsed_as s(:defs,
125
- s(:self),
126
- :foo, s(:args),
127
- s(:cvasgn, :@@bar, s(:call, nil, :baz)))
122
+ it "works inside a method with a receiver" do
123
+ _("def self.foo; @@bar = baz; end")
124
+ .must_be_parsed_as s(:defs,
125
+ s(:self),
126
+ :foo, s(:args),
127
+ s(:cvasgn, :@@bar, s(:call, nil, :baz)))
128
128
  end
129
129
 
130
- it 'works inside method arguments' do
131
- 'def foo(bar = (@@baz = qux)); end'.
132
- must_be_parsed_as s(:defn,
133
- :foo,
134
- s(:args,
135
- s(:lasgn, :bar,
136
- s(:cvasgn, :@@baz, s(:call, nil, :qux)))),
137
- s(:nil))
130
+ it "works inside method arguments" do
131
+ _("def foo(bar = (@@baz = qux)); end")
132
+ .must_be_parsed_as s(:defn,
133
+ :foo,
134
+ s(:args,
135
+ s(:lasgn, :bar,
136
+ s(:cvasgn, :@@baz, s(:call, nil, :qux)))),
137
+ s(:nil))
138
138
  end
139
139
 
140
- it 'works inside method arguments of a singleton method' do
141
- 'def self.foo(bar = (@@baz = qux)); end'.
142
- must_be_parsed_as s(:defs,
143
- s(:self),
144
- :foo,
145
- s(:args,
146
- s(:lasgn, :bar,
147
- s(:cvasgn, :@@baz, s(:call, nil, :qux)))),
148
- s(:nil))
140
+ it "works inside method arguments of a singleton method" do
141
+ _("def self.foo(bar = (@@baz = qux)); end")
142
+ .must_be_parsed_as s(:defs,
143
+ s(:self),
144
+ :foo,
145
+ s(:args,
146
+ s(:lasgn, :bar,
147
+ s(:cvasgn, :@@baz, s(:call, nil, :qux)))),
148
+ s(:nil))
149
149
  end
150
150
 
151
- it 'works inside the receiver in a method definition' do
152
- 'def (bar = (@@baz = qux)).foo; end'.
153
- must_be_parsed_as s(:defs,
154
- s(:lasgn, :bar,
155
- s(:cvdecl, :@@baz,
156
- s(:call, nil, :qux))), :foo,
157
- s(:args), s(:nil))
151
+ it "works inside the receiver in a method definition" do
152
+ _("def (bar = (@@baz = qux)).foo; end")
153
+ .must_be_parsed_as s(:defs,
154
+ s(:lasgn, :bar,
155
+ s(:cvdecl, :@@baz,
156
+ s(:call, nil, :qux))), :foo,
157
+ s(:args), s(:nil))
158
158
  end
159
159
  end
160
160
 
161
- it 'works when assigning to a global variable' do
162
- '$foo = bar'.
163
- must_be_parsed_as s(:gasgn,
164
- :$foo,
165
- s(:call, nil, :bar))
161
+ it "works when assigning to a global variable" do
162
+ _("$foo = bar")
163
+ .must_be_parsed_as s(:gasgn,
164
+ :$foo,
165
+ s(:call, nil, :bar))
166
166
  end
167
167
 
168
- describe 'with a rescue modifier' do
169
- it 'works with assigning a bare method call' do
170
- 'foo = bar rescue baz'.
171
- must_be_parsed_as s(:lasgn, :foo,
172
- s(:rescue,
173
- s(:call, nil, :bar),
174
- s(:resbody, s(:array), s(:call, nil, :baz))))
168
+ describe "with a rescue modifier" do
169
+ it "works with assigning a bare method call" do
170
+ _("foo = bar rescue baz")
171
+ .must_be_parsed_as s(:lasgn, :foo,
172
+ s(:rescue,
173
+ s(:call, nil, :bar),
174
+ s(:resbody, s(:array), s(:call, nil, :baz))))
175
175
  end
176
176
 
177
- it 'works with a method call with argument' do
178
- 'foo = bar(baz) rescue qux'.
179
- must_be_parsed_as s(:lasgn, :foo,
180
- s(:rescue,
181
- s(:call, nil, :bar, s(:call, nil, :baz)),
182
- s(:resbody, s(:array), s(:call, nil, :qux))))
177
+ it "works with a method call with argument" do
178
+ _("foo = bar(baz) rescue qux")
179
+ .must_be_parsed_as s(:lasgn, :foo,
180
+ s(:rescue,
181
+ s(:call, nil, :bar, s(:call, nil, :baz)),
182
+ s(:resbody, s(:array), s(:call, nil, :qux))))
183
183
  end
184
184
 
185
- it 'works with a method call with argument without brackets' do
186
- expected = if RUBY_VERSION < '2.4.0'
185
+ it "works with a method call with argument without brackets" do
186
+ expected = if RUBY_VERSION < "2.4.0"
187
187
  s(:rescue,
188
- s(:lasgn, :foo, s(:call, nil, :bar, s(:call, nil, :baz))),
188
+ s(:lasgn, :foo,
189
+ s(:call, nil, :bar, s(:call, nil, :baz))),
189
190
  s(:resbody, s(:array), s(:call, nil, :qux)))
190
191
  else
191
192
  s(:lasgn, :foo,
@@ -193,13 +194,14 @@ describe RipperRubyParser::Parser do
193
194
  s(:call, nil, :bar, s(:call, nil, :baz)),
194
195
  s(:resbody, s(:array), s(:call, nil, :qux))))
195
196
  end
196
- 'foo = bar baz rescue qux'.must_be_parsed_as expected
197
+ _("foo = bar baz rescue qux").must_be_parsed_as expected
197
198
  end
198
199
 
199
- it 'works with a class method call with argument without brackets' do
200
- expected = if RUBY_VERSION < '2.4.0'
200
+ it "works with a class method call with argument without brackets" do
201
+ expected = if RUBY_VERSION < "2.4.0"
201
202
  s(:rescue,
202
- s(:lasgn, :foo, s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux))),
203
+ s(:lasgn, :foo,
204
+ s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux))),
203
205
  s(:resbody, s(:array), s(:call, nil, :quuz)))
204
206
  else
205
207
  s(:lasgn, :foo,
@@ -207,14 +209,15 @@ describe RipperRubyParser::Parser do
207
209
  s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux)),
208
210
  s(:resbody, s(:array), s(:call, nil, :quuz))))
209
211
  end
210
- 'foo = Bar.baz qux rescue quuz'.
211
- must_be_parsed_as expected
212
+ _("foo = Bar.baz qux rescue quuz")
213
+ .must_be_parsed_as expected
212
214
  end
213
215
 
214
- it 'works with a method call with argument without brackets' do
215
- expected = if RUBY_VERSION < '2.4.0'
216
+ it "works with a method call with argument without brackets" do
217
+ expected = if RUBY_VERSION < "2.4.0"
216
218
  s(:rescue,
217
- s(:lasgn, :foo, s(:call, nil, :bar, s(:call, nil, :baz))),
219
+ s(:lasgn, :foo,
220
+ s(:call, nil, :bar, s(:call, nil, :baz))),
218
221
  s(:resbody, s(:array), s(:call, nil, :qux)))
219
222
  else
220
223
  s(:lasgn, :foo,
@@ -222,13 +225,14 @@ describe RipperRubyParser::Parser do
222
225
  s(:call, nil, :bar, s(:call, nil, :baz)),
223
226
  s(:resbody, s(:array), s(:call, nil, :qux))))
224
227
  end
225
- 'foo = bar baz rescue qux'.must_be_parsed_as expected
228
+ _("foo = bar baz rescue qux").must_be_parsed_as expected
226
229
  end
227
230
 
228
- it 'works with a class method call with argument without brackets' do
229
- expected = if RUBY_VERSION < '2.4.0'
231
+ it "works with a class method call with argument without brackets" do
232
+ expected = if RUBY_VERSION < "2.4.0"
230
233
  s(:rescue,
231
- s(:lasgn, :foo, s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux))),
234
+ s(:lasgn, :foo,
235
+ s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux))),
232
236
  s(:resbody, s(:array), s(:call, nil, :quuz)))
233
237
  else
234
238
  s(:lasgn, :foo,
@@ -236,413 +240,373 @@ describe RipperRubyParser::Parser do
236
240
  s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux)),
237
241
  s(:resbody, s(:array), s(:call, nil, :quuz))))
238
242
  end
239
- 'foo = Bar.baz qux rescue quuz'.
240
- must_be_parsed_as expected
243
+ _("foo = Bar.baz qux rescue quuz")
244
+ .must_be_parsed_as expected
241
245
  end
242
246
  end
243
247
 
244
- it 'sets the correct line numbers' do
245
- result = parser.parse 'foo = {}'
246
- result.line.must_equal 1
248
+ it "sets the correct line numbers" do
249
+ result = parser.parse "foo = {}"
250
+ _(result.line).must_equal 1
247
251
  end
248
252
  end
249
253
 
250
- describe 'for multiple assignment' do
254
+ describe "for multiple assignment" do
251
255
  specify do
252
- 'foo, * = bar'.
253
- must_be_parsed_as s(:masgn,
254
- s(:array, s(:lasgn, :foo), s(:splat)),
255
- s(:to_ary, s(:call, nil, :bar)))
256
+ _("foo, * = bar")
257
+ .must_be_parsed_as s(:masgn,
258
+ s(:array, s(:lasgn, :foo), s(:splat)),
259
+ s(:to_ary, s(:call, nil, :bar)))
256
260
  end
257
261
 
258
262
  specify do
259
- '(foo, *bar) = baz'.
260
- must_be_parsed_as s(:masgn,
261
- s(:array,
262
- s(:lasgn, :foo),
263
- s(:splat, s(:lasgn, :bar))),
264
- s(:to_ary, s(:call, nil, :baz)))
263
+ _("(foo, *bar) = baz")
264
+ .must_be_parsed_as s(:masgn,
265
+ s(:array,
266
+ s(:lasgn, :foo),
267
+ s(:splat, s(:lasgn, :bar))),
268
+ s(:to_ary, s(:call, nil, :baz)))
265
269
  end
266
270
 
267
271
  specify do
268
- '*foo, bar = baz'.
269
- must_be_parsed_as s(:masgn,
270
- s(:array,
271
- s(:splat, s(:lasgn, :foo)),
272
- s(:lasgn, :bar)),
273
- s(:to_ary, s(:call, nil, :baz)))
274
- end
275
-
276
- it 'works with blocks' do
277
- 'foo, bar = begin; baz; end'.
278
- must_be_parsed_as s(:masgn,
279
- s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
280
- s(:to_ary, s(:call, nil, :baz)))
281
- end
282
-
283
- it 'works with a rescue modifier' do
284
- 'foo, bar = baz rescue qux'.
285
- must_be_parsed_as s(:rescue,
286
- s(:masgn,
287
- s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
288
- s(:to_ary, s(:call, nil, :baz))),
289
- s(:resbody, s(:array), s(:call, nil, :qux)))
290
- end
291
-
292
- it 'works the same number of items on each side' do
293
- 'foo, bar = baz, qux'.
294
- must_be_parsed_as s(:masgn,
295
- s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
296
- s(:array,
297
- s(:call, nil, :baz),
298
- s(:call, nil, :qux)))
299
- end
300
-
301
- it 'works with a single item on the right-hand side' do
302
- 'foo, bar = baz'.
303
- must_be_parsed_as s(:masgn,
304
- s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
305
- s(:to_ary, s(:call, nil, :baz)))
306
- end
307
-
308
- it 'works with left-hand splat' do
309
- 'foo, *bar = baz, qux'.
310
- must_be_parsed_as s(:masgn,
311
- s(:array, s(:lasgn, :foo), s(:splat, s(:lasgn, :bar))),
312
- s(:array,
313
- s(:call, nil, :baz),
314
- s(:call, nil, :qux)))
315
- end
316
-
317
- it 'works with parentheses around the left-hand side' do
318
- '(foo, bar) = baz'.
319
- must_be_parsed_as s(:masgn,
320
- s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
321
- s(:to_ary, s(:call, nil, :baz)))
322
- end
323
-
324
- it 'works with complex destructuring' do
325
- 'foo, (bar, baz) = qux'.
326
- must_be_parsed_as s(:masgn,
327
- s(:array,
328
- s(:lasgn, :foo),
329
- s(:masgn,
330
- s(:array,
331
- s(:lasgn, :bar),
332
- s(:lasgn, :baz)))),
333
- s(:to_ary, s(:call, nil, :qux)))
334
- end
335
-
336
- it 'works with complex destructuring of the value' do
337
- 'foo, (bar, baz) = [qux, [quz, quuz]]'.
338
- must_be_parsed_as s(:masgn,
339
- s(:array,
340
- s(:lasgn, :foo),
341
- s(:masgn,
342
- s(:array,
343
- s(:lasgn, :bar),
344
- s(:lasgn, :baz)))),
345
- s(:to_ary,
346
- s(:array,
347
- s(:call, nil, :qux),
348
- s(:array,
349
- s(:call, nil, :quz),
350
- s(:call, nil, :quuz)))))
351
- end
352
-
353
- it 'works with destructuring with multiple levels' do
354
- '((foo, bar)) = baz'.
355
- must_be_parsed_as s(:masgn,
356
- s(:array,
357
- s(:masgn,
358
- s(:array,
359
- s(:lasgn, :foo),
360
- s(:lasgn, :bar)))),
361
- s(:to_ary, s(:call, nil, :baz)))
362
- end
363
-
364
- it 'works with instance variables' do
365
- '@foo, @bar = baz'.
366
- must_be_parsed_as s(:masgn,
367
- s(:array, s(:iasgn, :@foo), s(:iasgn, :@bar)),
368
- s(:to_ary, s(:call, nil, :baz)))
369
- end
370
-
371
- it 'works with class variables' do
372
- '@@foo, @@bar = baz'.
373
- must_be_parsed_as s(:masgn,
374
- s(:array, s(:cvdecl, :@@foo), s(:cvdecl, :@@bar)),
375
- s(:to_ary, s(:call, nil, :baz)))
376
- end
377
-
378
- it 'works with attributes' do
379
- 'foo.bar, foo.baz = qux'.
380
- must_be_parsed_as s(:masgn,
381
- s(:array,
382
- s(:attrasgn, s(:call, nil, :foo), :bar=),
383
- s(:attrasgn, s(:call, nil, :foo), :baz=)),
384
- s(:to_ary, s(:call, nil, :qux)))
385
- end
386
-
387
- it 'works with collection elements' do
388
- 'foo[1], bar[2] = baz'.
389
- must_be_parsed_as s(:masgn,
390
- s(:array,
391
- s(:attrasgn,
392
- s(:call, nil, :foo), :[]=, s(:lit, 1)),
393
- s(:attrasgn,
394
- s(:call, nil, :bar), :[]=, s(:lit, 2))),
395
- s(:to_ary, s(:call, nil, :baz)))
396
- end
397
-
398
- it 'works with constants' do
399
- 'Foo, Bar = baz'.
400
- must_be_parsed_as s(:masgn,
401
- s(:array, s(:cdecl, :Foo), s(:cdecl, :Bar)),
402
- s(:to_ary, s(:call, nil, :baz)))
403
- end
404
-
405
- it 'works with instance variables and splat' do
406
- '@foo, *@bar = baz'.
407
- must_be_parsed_as s(:masgn,
408
- s(:array,
409
- s(:iasgn, :@foo),
410
- s(:splat, s(:iasgn, :@bar))),
411
- s(:to_ary, s(:call, nil, :baz)))
412
- end
413
-
414
- it 'works with a right-hand single splat' do
415
- 'foo, bar = *baz'.
416
- must_be_parsed_as s(:masgn,
417
- s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
418
- s(:splat, s(:call, nil, :baz)))
419
- end
420
-
421
- it 'works with a splat in a list of values on the right hand' do
422
- 'foo, bar = baz, *qux'.
423
- must_be_parsed_as s(:masgn,
424
- s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
425
- s(:array,
426
- s(:call, nil, :baz),
427
- s(:splat, s(:call, nil, :qux))))
428
- end
429
-
430
- it 'works with a right-hand single splat with begin..end block' do
431
- 'foo, bar = *begin; baz; end'.
432
- must_be_parsed_as s(:masgn,
433
- s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
434
- s(:splat,
435
- s(:call, nil, :baz)))
436
- end
437
-
438
- it 'sets the correct line numbers' do
439
- result = parser.parse 'foo, bar = {}, {}'
440
- result.line.must_equal 1
272
+ _("*foo, bar = baz")
273
+ .must_be_parsed_as s(:masgn,
274
+ s(:array,
275
+ s(:splat, s(:lasgn, :foo)),
276
+ s(:lasgn, :bar)),
277
+ s(:to_ary, s(:call, nil, :baz)))
278
+ end
279
+
280
+ it "works with blocks" do
281
+ _("foo, bar = begin; baz; end")
282
+ .must_be_parsed_as s(:masgn,
283
+ s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
284
+ s(:to_ary, s(:call, nil, :baz)))
285
+ end
286
+
287
+ it "works with a rescue modifier" do
288
+ _("foo, bar = baz rescue qux")
289
+ .must_be_parsed_as s(:rescue,
290
+ s(:masgn,
291
+ s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
292
+ s(:to_ary, s(:call, nil, :baz))),
293
+ s(:resbody, s(:array), s(:call, nil, :qux)))
294
+ end
295
+
296
+ it "works the same number of items on each side" do
297
+ _("foo, bar = baz, qux")
298
+ .must_be_parsed_as s(:masgn,
299
+ s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
300
+ s(:array,
301
+ s(:call, nil, :baz),
302
+ s(:call, nil, :qux)))
303
+ end
304
+
305
+ it "works with a single item on the right-hand side" do
306
+ _("foo, bar = baz")
307
+ .must_be_parsed_as s(:masgn,
308
+ s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
309
+ s(:to_ary, s(:call, nil, :baz)))
310
+ end
311
+
312
+ it "works with left-hand splat" do
313
+ _("foo, *bar = baz, qux")
314
+ .must_be_parsed_as s(:masgn,
315
+ s(:array, s(:lasgn, :foo), s(:splat, s(:lasgn, :bar))),
316
+ s(:array,
317
+ s(:call, nil, :baz),
318
+ s(:call, nil, :qux)))
319
+ end
320
+
321
+ it "works with parentheses around the left-hand side" do
322
+ _("(foo, bar) = baz")
323
+ .must_be_parsed_as s(:masgn,
324
+ s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
325
+ s(:to_ary, s(:call, nil, :baz)))
326
+ end
327
+
328
+ it "works with complex destructuring" do
329
+ _("foo, (bar, baz) = qux")
330
+ .must_be_parsed_as s(:masgn,
331
+ s(:array,
332
+ s(:lasgn, :foo),
333
+ s(:masgn,
334
+ s(:array,
335
+ s(:lasgn, :bar),
336
+ s(:lasgn, :baz)))),
337
+ s(:to_ary, s(:call, nil, :qux)))
338
+ end
339
+
340
+ it "works with complex destructuring of the value" do
341
+ _("foo, (bar, baz) = [qux, [quz, quuz]]")
342
+ .must_be_parsed_as s(:masgn,
343
+ s(:array,
344
+ s(:lasgn, :foo),
345
+ s(:masgn,
346
+ s(:array,
347
+ s(:lasgn, :bar),
348
+ s(:lasgn, :baz)))),
349
+ s(:to_ary,
350
+ s(:array,
351
+ s(:call, nil, :qux),
352
+ s(:array,
353
+ s(:call, nil, :quz),
354
+ s(:call, nil, :quuz)))))
355
+ end
356
+
357
+ it "works with destructuring with multiple levels" do
358
+ _("((foo, bar)) = baz")
359
+ .must_be_parsed_as s(:masgn,
360
+ s(:array,
361
+ s(:masgn,
362
+ s(:array,
363
+ s(:lasgn, :foo),
364
+ s(:lasgn, :bar)))),
365
+ s(:to_ary, s(:call, nil, :baz)))
366
+ end
367
+
368
+ it "works with instance variables" do
369
+ _("@foo, @bar = baz")
370
+ .must_be_parsed_as s(:masgn,
371
+ s(:array, s(:iasgn, :@foo), s(:iasgn, :@bar)),
372
+ s(:to_ary, s(:call, nil, :baz)))
373
+ end
374
+
375
+ it "works with class variables" do
376
+ _("@@foo, @@bar = baz")
377
+ .must_be_parsed_as s(:masgn,
378
+ s(:array, s(:cvdecl, :@@foo), s(:cvdecl, :@@bar)),
379
+ s(:to_ary, s(:call, nil, :baz)))
380
+ end
381
+
382
+ it "works with attributes" do
383
+ _("foo.bar, foo.baz = qux")
384
+ .must_be_parsed_as s(:masgn,
385
+ s(:array,
386
+ s(:attrasgn, s(:call, nil, :foo), :bar=),
387
+ s(:attrasgn, s(:call, nil, :foo), :baz=)),
388
+ s(:to_ary, s(:call, nil, :qux)))
389
+ end
390
+
391
+ it "works with collection elements" do
392
+ _("foo[1], bar[2] = baz")
393
+ .must_be_parsed_as s(:masgn,
394
+ s(:array,
395
+ s(:attrasgn,
396
+ s(:call, nil, :foo), :[]=, s(:lit, 1)),
397
+ s(:attrasgn,
398
+ s(:call, nil, :bar), :[]=, s(:lit, 2))),
399
+ s(:to_ary, s(:call, nil, :baz)))
400
+ end
401
+
402
+ it "works with constants" do
403
+ _("Foo, Bar = baz")
404
+ .must_be_parsed_as s(:masgn,
405
+ s(:array, s(:cdecl, :Foo), s(:cdecl, :Bar)),
406
+ s(:to_ary, s(:call, nil, :baz)))
407
+ end
408
+
409
+ it "works with instance variables and splat" do
410
+ _("@foo, *@bar = baz")
411
+ .must_be_parsed_as s(:masgn,
412
+ s(:array,
413
+ s(:iasgn, :@foo),
414
+ s(:splat, s(:iasgn, :@bar))),
415
+ s(:to_ary, s(:call, nil, :baz)))
416
+ end
417
+
418
+ it "works with a right-hand single splat" do
419
+ _("foo, bar = *baz")
420
+ .must_be_parsed_as s(:masgn,
421
+ s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
422
+ s(:splat, s(:call, nil, :baz)))
423
+ end
424
+
425
+ it "works with a splat in a list of values on the right hand" do
426
+ _("foo, bar = baz, *qux")
427
+ .must_be_parsed_as s(:masgn,
428
+ s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
429
+ s(:array,
430
+ s(:call, nil, :baz),
431
+ s(:splat, s(:call, nil, :qux))))
432
+ end
433
+
434
+ it "works with a right-hand single splat with begin..end block" do
435
+ _("foo, bar = *begin; baz; end")
436
+ .must_be_parsed_as s(:masgn,
437
+ s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
438
+ s(:splat,
439
+ s(:call, nil, :baz)))
440
+ end
441
+
442
+ it "sets the correct line numbers" do
443
+ result = parser.parse "foo, bar = {}, {}"
444
+ _(result.line).must_equal 1
441
445
  end
442
446
  end
443
447
 
444
- describe 'for assignment to a collection element' do
445
- it 'handles multiple indices' do
446
- 'foo[bar, baz] = qux'.
447
- must_be_parsed_as s(:attrasgn,
448
- s(:call, nil, :foo),
449
- :[]=,
450
- s(:call, nil, :bar),
451
- s(:call, nil, :baz),
452
- s(:call, nil, :qux))
448
+ describe "for assignment to a collection element" do
449
+ it "handles multiple indices" do
450
+ _("foo[bar, baz] = qux")
451
+ .must_be_parsed_as s(:attrasgn,
452
+ s(:call, nil, :foo),
453
+ :[]=,
454
+ s(:call, nil, :bar),
455
+ s(:call, nil, :baz),
456
+ s(:call, nil, :qux))
453
457
  end
454
458
  end
455
459
 
456
- describe 'for operator assignment' do
457
- it 'works with +=' do
458
- 'foo += bar'.
459
- must_be_parsed_as s(:lasgn, :foo,
460
- s(:call, s(:lvar, :foo),
461
- :+,
462
- s(:call, nil, :bar)))
460
+ describe "for operator assignment" do
461
+ it "works with +=" do
462
+ _("foo += bar")
463
+ .must_be_parsed_as s(:lasgn, :foo,
464
+ s(:call, s(:lvar, :foo),
465
+ :+,
466
+ s(:call, nil, :bar)))
463
467
  end
464
468
 
465
- it 'works with -=' do
466
- 'foo -= bar'.
467
- must_be_parsed_as s(:lasgn, :foo,
468
- s(:call, s(:lvar, :foo),
469
- :-,
470
- s(:call, nil, :bar)))
469
+ it "works with -=" do
470
+ _("foo -= bar")
471
+ .must_be_parsed_as s(:lasgn, :foo,
472
+ s(:call, s(:lvar, :foo),
473
+ :-,
474
+ s(:call, nil, :bar)))
471
475
  end
472
476
 
473
- it 'works with *=' do
474
- 'foo *= bar'.
475
- must_be_parsed_as s(:lasgn, :foo,
476
- s(:call, s(:lvar, :foo),
477
- :*,
478
- s(:call, nil, :bar)))
477
+ it "works with *=" do
478
+ _("foo *= bar")
479
+ .must_be_parsed_as s(:lasgn, :foo,
480
+ s(:call, s(:lvar, :foo),
481
+ :*,
482
+ s(:call, nil, :bar)))
479
483
  end
480
484
 
481
- it 'works with /=' do
482
- 'foo /= bar'.
483
- must_be_parsed_as s(:lasgn, :foo,
484
- s(:call,
485
- s(:lvar, :foo), :/,
486
- s(:call, nil, :bar)))
485
+ it "works with /=" do
486
+ _("foo /= bar")
487
+ .must_be_parsed_as s(:lasgn, :foo,
488
+ s(:call,
489
+ s(:lvar, :foo), :/,
490
+ s(:call, nil, :bar)))
487
491
  end
488
492
 
489
- it 'works with ||=' do
490
- 'foo ||= bar'.
491
- must_be_parsed_as s(:op_asgn_or,
492
- s(:lvar, :foo),
493
- s(:lasgn, :foo,
494
- s(:call, nil, :bar)))
493
+ it "works with ||=" do
494
+ _("foo ||= bar")
495
+ .must_be_parsed_as s(:op_asgn_or,
496
+ s(:lvar, :foo),
497
+ s(:lasgn, :foo,
498
+ s(:call, nil, :bar)))
495
499
  end
496
500
 
497
- it 'works when assigning to an instance variable' do
498
- '@foo += bar'.
499
- must_be_parsed_as s(:iasgn, :@foo,
500
- s(:call,
501
- s(:ivar, :@foo), :+,
502
- s(:call, nil, :bar)))
501
+ it "works when assigning to an instance variable" do
502
+ _("@foo += bar")
503
+ .must_be_parsed_as s(:iasgn, :@foo,
504
+ s(:call,
505
+ s(:ivar, :@foo), :+,
506
+ s(:call, nil, :bar)))
503
507
  end
504
508
 
505
- it 'works with boolean operators' do
506
- 'foo &&= bar'.
507
- must_be_parsed_as s(:op_asgn_and,
508
- s(:lvar, :foo), s(:lasgn, :foo, s(:call, nil, :bar)))
509
+ it "works with boolean operators" do
510
+ _("foo &&= bar")
511
+ .must_be_parsed_as s(:op_asgn_and,
512
+ s(:lvar, :foo), s(:lasgn, :foo, s(:call, nil, :bar)))
509
513
  end
510
514
 
511
- it 'works with boolean operators and blocks' do
512
- 'foo &&= begin; bar; end'.
513
- must_be_parsed_as s(:op_asgn_and,
514
- s(:lvar, :foo), s(:lasgn, :foo, s(:call, nil, :bar)))
515
+ it "works with boolean operators and blocks" do
516
+ _("foo &&= begin; bar; end")
517
+ .must_be_parsed_as s(:op_asgn_and,
518
+ s(:lvar, :foo), s(:lasgn, :foo, s(:call, nil, :bar)))
515
519
  end
516
520
 
517
- it 'works with arithmetic operators and blocks' do
518
- 'foo += begin; bar; end'.
519
- must_be_parsed_as s(:lasgn, :foo,
520
- s(:call, s(:lvar, :foo), :+, s(:call, nil, :bar)))
521
+ it "works with arithmetic operators and blocks" do
522
+ _("foo += begin; bar; end")
523
+ .must_be_parsed_as s(:lasgn, :foo,
524
+ s(:call, s(:lvar, :foo), :+, s(:call, nil, :bar)))
521
525
  end
522
526
  end
523
527
 
524
- describe 'for operator assignment to an attribute' do
525
- it 'works with +=' do
526
- 'foo.bar += baz'.
527
- must_be_parsed_as s(:op_asgn2,
528
- s(:call, nil, :foo),
529
- :bar=, :+,
530
- s(:call, nil, :baz))
528
+ describe "for operator assignment to an attribute" do
529
+ it "works with +=" do
530
+ _("foo.bar += baz")
531
+ .must_be_parsed_as s(:op_asgn2,
532
+ s(:call, nil, :foo),
533
+ :bar=, :+,
534
+ s(:call, nil, :baz))
531
535
  end
532
536
 
533
- it 'works with ||=' do
534
- 'foo.bar ||= baz'.
535
- must_be_parsed_as s(:op_asgn2,
536
- s(:call, nil, :foo),
537
- :bar=, :'||',
538
- s(:call, nil, :baz))
537
+ it "works with ||=" do
538
+ _("foo.bar ||= baz")
539
+ .must_be_parsed_as s(:op_asgn2,
540
+ s(:call, nil, :foo),
541
+ :bar=, :'||',
542
+ s(:call, nil, :baz))
539
543
  end
540
544
  end
541
545
 
542
- describe 'for operator assignment to a collection element' do
543
- it 'works with +=' do
544
- 'foo[bar] += baz'.
545
- must_be_parsed_as s(:op_asgn1,
546
- s(:call, nil, :foo),
547
- s(:arglist, s(:call, nil, :bar)),
548
- :+,
549
- s(:call, nil, :baz))
550
- end
551
-
552
- it 'works with ||=' do
553
- 'foo[bar] ||= baz'.
554
- must_be_parsed_as s(:op_asgn1,
555
- s(:call, nil, :foo),
556
- s(:arglist, s(:call, nil, :bar)),
557
- :"||",
558
- s(:call, nil, :baz))
559
- end
560
-
561
- it 'handles multiple indices' do
562
- 'foo[bar, baz] += qux'.
563
- must_be_parsed_as s(:op_asgn1,
564
- s(:call, nil, :foo),
565
- s(:arglist,
566
- s(:call, nil, :bar),
567
- s(:call, nil, :baz)),
568
- :+,
569
- s(:call, nil, :qux))
570
- end
571
-
572
- it 'works with a function call without parentheses' do
573
- 'foo[bar] += baz qux'.
574
- must_be_parsed_as s(:op_asgn1,
575
- s(:call, nil, :foo),
576
- s(:arglist, s(:call, nil, :bar)),
577
- :+,
578
- s(:call, nil, :baz, s(:call, nil, :qux)))
579
- end
580
-
581
- it 'works with a function call with parentheses' do
582
- 'foo[bar] += baz(qux)'.
583
- must_be_parsed_as s(:op_asgn1,
584
- s(:call, nil, :foo),
585
- s(:arglist, s(:call, nil, :bar)),
586
- :+,
587
- s(:call, nil, :baz, s(:call, nil, :qux)))
588
- end
589
-
590
- it 'works with a method call without parentheses' do
591
- 'foo[bar] += baz.qux quuz'.
592
- must_be_parsed_as s(:op_asgn1,
593
- s(:call, nil, :foo),
594
- s(:arglist, s(:call, nil, :bar)),
595
- :+,
596
- s(:call, s(:call, nil, :baz), :qux, s(:call, nil, :quuz)))
597
- end
598
-
599
- it 'works with a method call with parentheses' do
600
- 'foo[bar] += baz.qux(quuz)'.
601
- must_be_parsed_as s(:op_asgn1,
602
- s(:call, nil, :foo),
603
- s(:arglist, s(:call, nil, :bar)),
604
- :+,
605
- s(:call, s(:call, nil, :baz), :qux, s(:call, nil, :quuz)))
606
- end
607
-
608
- it 'works with a function call without parentheses in extra compatible mode' do
609
- 'foo[bar] += baz qux'.
610
- must_be_parsed_as s(:op_asgn1,
611
- s(:call, nil, :foo),
612
- s(:array, s(:call, nil, :bar)),
613
- :+,
614
- s(:call, nil, :baz, s(:call, nil, :qux))),
615
- extra_compatible: true
616
- end
617
-
618
- it 'works with a function call with parentheses in extra compatible mode' do
619
- 'foo[bar] += baz(qux)'.
620
- must_be_parsed_as s(:op_asgn1,
621
- s(:call, nil, :foo),
622
- s(:arglist, s(:call, nil, :bar)),
623
- :+,
624
- s(:call, nil, :baz, s(:call, nil, :qux))),
625
- extra_compatible: true
626
- end
627
-
628
- it 'works with a method call without parentheses in extra compatible mode' do
629
- 'foo[bar] += baz.qux quuz'.
630
- must_be_parsed_as s(:op_asgn1,
631
- s(:call, nil, :foo),
632
- s(:array, s(:call, nil, :bar)),
633
- :+,
634
- s(:call, s(:call, nil, :baz), :qux, s(:call, nil, :quuz))),
635
- extra_compatible: true
636
- end
637
-
638
- it 'works with a method call with parentheses in extra compatible mode' do
639
- 'foo[bar] += baz.qux(quuz)'.
640
- must_be_parsed_as s(:op_asgn1,
641
- s(:call, nil, :foo),
642
- s(:arglist, s(:call, nil, :bar)),
643
- :+,
644
- s(:call, s(:call, nil, :baz), :qux, s(:call, nil, :quuz))),
645
- extra_compatible: true
546
+ describe "for operator assignment to a collection element" do
547
+ it "works with +=" do
548
+ _("foo[bar] += baz")
549
+ .must_be_parsed_as s(:op_asgn1,
550
+ s(:call, nil, :foo),
551
+ s(:arglist, s(:call, nil, :bar)),
552
+ :+,
553
+ s(:call, nil, :baz))
554
+ end
555
+
556
+ it "works with ||=" do
557
+ _("foo[bar] ||= baz")
558
+ .must_be_parsed_as s(:op_asgn1,
559
+ s(:call, nil, :foo),
560
+ s(:arglist, s(:call, nil, :bar)),
561
+ :"||",
562
+ s(:call, nil, :baz))
563
+ end
564
+
565
+ it "handles multiple indices" do
566
+ _("foo[bar, baz] += qux")
567
+ .must_be_parsed_as s(:op_asgn1,
568
+ s(:call, nil, :foo),
569
+ s(:arglist,
570
+ s(:call, nil, :bar),
571
+ s(:call, nil, :baz)),
572
+ :+,
573
+ s(:call, nil, :qux))
574
+ end
575
+
576
+ it "works with a function call without parentheses" do
577
+ _("foo[bar] += baz qux")
578
+ .must_be_parsed_as s(:op_asgn1,
579
+ s(:call, nil, :foo),
580
+ s(:arglist, s(:call, nil, :bar)),
581
+ :+,
582
+ s(:call, nil, :baz, s(:call, nil, :qux)))
583
+ end
584
+
585
+ it "works with a function call with parentheses" do
586
+ _("foo[bar] += baz(qux)")
587
+ .must_be_parsed_as s(:op_asgn1,
588
+ s(:call, nil, :foo),
589
+ s(:arglist, s(:call, nil, :bar)),
590
+ :+,
591
+ s(:call, nil, :baz, s(:call, nil, :qux)))
592
+ end
593
+
594
+ it "works with a method call without parentheses" do
595
+ _("foo[bar] += baz.qux quuz")
596
+ .must_be_parsed_as s(:op_asgn1,
597
+ s(:call, nil, :foo),
598
+ s(:arglist, s(:call, nil, :bar)),
599
+ :+,
600
+ s(:call, s(:call, nil, :baz), :qux, s(:call, nil, :quuz)))
601
+ end
602
+
603
+ it "works with a method call with parentheses" do
604
+ _("foo[bar] += baz.qux(quuz)")
605
+ .must_be_parsed_as s(:op_asgn1,
606
+ s(:call, nil, :foo),
607
+ s(:arglist, s(:call, nil, :bar)),
608
+ :+,
609
+ s(:call, s(:call, nil, :baz), :qux, s(:call, nil, :quuz)))
646
610
  end
647
611
  end
648
612
  end