ripper_ruby_parser 1.1.1 → 1.1.2

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 (36) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +19 -0
  3. data/Rakefile +2 -2
  4. data/lib/ripper_ruby_parser/commenting_ripper_parser.rb +55 -4
  5. data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb +20 -13
  6. data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb +27 -12
  7. data/lib/ripper_ruby_parser/sexp_handlers/hashes.rb +25 -12
  8. data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb +4 -2
  9. data/lib/ripper_ruby_parser/sexp_handlers/literals.rb +19 -15
  10. data/lib/ripper_ruby_parser/sexp_handlers/loops.rb +25 -11
  11. data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb +12 -4
  12. data/lib/ripper_ruby_parser/sexp_handlers/methods.rb +8 -4
  13. data/lib/ripper_ruby_parser/sexp_handlers/operators.rb +1 -5
  14. data/lib/ripper_ruby_parser/version.rb +1 -1
  15. data/lib/ripper_ruby_parser.rb +2 -2
  16. data/test/end_to_end/comments_test.rb +4 -4
  17. data/test/end_to_end/comparison_test.rb +15 -15
  18. data/test/end_to_end/error_conditions_test.rb +16 -16
  19. data/test/end_to_end/lib_comparison_test.rb +3 -3
  20. data/test/end_to_end/line_numbering_test.rb +4 -4
  21. data/test/end_to_end/samples_comparison_test.rb +4 -4
  22. data/test/end_to_end/test_comparison_test.rb +3 -3
  23. data/test/pt_testcase/pt_test.rb +4 -4
  24. data/test/test_helper.rb +1 -1
  25. data/test/unit/commenting_ripper_parser_test.rb +33 -33
  26. data/test/unit/parser_assignment_test.rb +30 -30
  27. data/test/unit/parser_blocks_test.rb +83 -65
  28. data/test/unit/parser_conditionals_test.rb +96 -64
  29. data/test/unit/parser_literals_test.rb +308 -212
  30. data/test/unit/parser_loops_test.rb +85 -15
  31. data/test/unit/parser_method_calls_test.rb +100 -41
  32. data/test/unit/parser_operators_test.rb +60 -28
  33. data/test/unit/parser_test.rb +435 -410
  34. data/test/unit/sexp_processor_test.rb +82 -82
  35. data/test/unit/version_test.rb +1 -1
  36. metadata +2 -2
data/test/unit/parser_conditionals_test.rb CHANGED
@@ -1,18 +1,18 @@
1
1
  require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
2
2
 
3
3
  describe RipperRubyParser::Parser do
4
- describe "#parse" do
5
- describe "for regular if" do
6
- it "works with a single statement" do
7
- "if foo; bar; end".
4
+ describe '#parse' do
5
+ describe 'for regular if' do
6
+ it 'works with a single statement' do
7
+ 'if foo; bar; end'.
8
8
  must_be_parsed_as s(:if,
9
9
  s(:call, nil, :foo),
10
10
  s(:call, nil, :bar),
11
11
  nil)
12
12
  end
13
13
 
14
- it "works with multiple statements" do
15
- "if foo; bar; baz; end".
14
+ it 'works with multiple statements' do
15
+ 'if foo; bar; baz; end'.
16
16
  must_be_parsed_as s(:if,
17
17
  s(:call, nil, :foo),
18
18
  s(:block,
@@ -21,16 +21,16 @@ describe RipperRubyParser::Parser do
21
21
  nil)
22
22
  end
23
23
 
24
- it "works with an else clause" do
25
- "if foo; bar; else; baz; end".
24
+ it 'works with an else clause' do
25
+ 'if foo; bar; else; baz; end'.
26
26
  must_be_parsed_as s(:if,
27
27
  s(:call, nil, :foo),
28
28
  s(:call, nil, :bar),
29
29
  s(:call, nil, :baz))
30
30
  end
31
31
 
32
- it "works with an elsif clause" do
33
- "if foo; bar; elsif baz; qux; end".
32
+ it 'works with an elsif clause' do
33
+ 'if foo; bar; elsif baz; qux; end'.
34
34
  must_be_parsed_as s(:if,
35
35
  s(:call, nil, :foo),
36
36
  s(:call, nil, :bar),
@@ -40,16 +40,16 @@ describe RipperRubyParser::Parser do
40
40
  nil))
41
41
  end
42
42
 
43
- it "handles a negative condition correctly" do
44
- "if not foo; bar; end".
43
+ it 'handles a negative condition correctly' do
44
+ 'if not foo; bar; end'.
45
45
  must_be_parsed_as s(:if,
46
46
  s(:call, s(:call, nil, :foo), :!),
47
47
  s(:call, nil, :bar),
48
48
  nil)
49
49
  end
50
50
 
51
- it "handles a negative condition in elsif correctly" do
52
- "if foo; bar; elsif not baz; qux; end".
51
+ it 'handles a negative condition in elsif correctly' do
52
+ 'if foo; bar; elsif not baz; qux; end'.
53
53
  must_be_parsed_as s(:if,
54
54
  s(:call, nil, :foo),
55
55
  s(:call, nil, :bar),
@@ -58,143 +58,175 @@ describe RipperRubyParser::Parser do
58
58
  s(:call, nil, :qux), nil))
59
59
  end
60
60
 
61
- it "handles bare regex literal in condition" do
62
- "if /foo/; bar; end".
61
+ it 'handles bare regex literal in condition' do
62
+ 'if /foo/; bar; end'.
63
63
  must_be_parsed_as s(:if,
64
64
  s(:match, s(:lit, /foo/)),
65
65
  s(:call, nil, :bar),
66
66
  nil)
67
67
  end
68
68
 
69
- it "handles interpolated regex in condition" do
69
+ it 'handles interpolated regex in condition' do
70
70
  'if /#{foo}/; bar; end'.
71
71
  must_be_parsed_as s(:if,
72
- s(:dregx, "", s(:evstr, s(:call, nil, :foo))),
72
+ s(:dregx, '', s(:evstr, s(:call, nil, :foo))),
73
73
  s(:call, nil, :bar),
74
74
  nil)
75
75
  end
76
76
 
77
- it "handles block conditions" do
78
- "if (foo; bar); baz; end".
77
+ it 'handles block conditions' do
78
+ 'if (foo; bar); baz; end'.
79
79
  must_be_parsed_as s(:if,
80
80
  s(:block, s(:call, nil, :foo), s(:call, nil, :bar)),
81
81
  s(:call, nil, :baz),
82
82
  nil)
83
83
  end
84
84
 
85
- it "converts :dot2 to :flip2" do
86
- "if foo..bar; baz; end".
85
+ it 'converts :dot2 to :flip2' do
86
+ 'if foo..bar; baz; end'.
87
87
  must_be_parsed_as s(:if,
88
88
  s(:flip2, s(:call, nil, :foo), s(:call, nil, :bar)),
89
89
  s(:call, nil, :baz),
90
90
  nil)
91
91
  end
92
92
 
93
- it "converts :dot3 to :flip3" do
94
- "if foo...bar; baz; end".
93
+ it 'converts :dot3 to :flip3' do
94
+ 'if foo...bar; baz; end'.
95
95
  must_be_parsed_as s(:if,
96
96
  s(:flip3, s(:call, nil, :foo), s(:call, nil, :bar)),
97
97
  s(:call, nil, :baz),
98
98
  nil)
99
99
  end
100
+
101
+ it 'handles negative match operator' do
102
+ 'if foo !~ bar; baz; else; qux; end'.
103
+ must_be_parsed_as s(:if,
104
+ s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
105
+ s(:call, nil, :qux),
106
+ s(:call, nil, :baz))
107
+ end
100
108
  end
101
109
 
102
- describe "for postfix if" do
103
- it "works with a simple condition" do
104
- "foo if bar".
110
+ describe 'for postfix if' do
111
+ it 'works with a simple condition' do
112
+ 'foo if bar'.
105
113
  must_be_parsed_as s(:if,
106
114
  s(:call, nil, :bar),
107
115
  s(:call, nil, :foo),
108
116
  nil)
109
117
  end
110
118
 
111
- it "handles negative conditions" do
112
- "foo if not bar".
119
+ it 'handles negative conditions' do
120
+ 'foo if not bar'.
113
121
  must_be_parsed_as s(:if,
114
122
  s(:call, s(:call, nil, :bar), :!),
115
123
  s(:call, nil, :foo),
116
124
  nil)
117
125
  end
118
126
 
119
- it "handles bare regex literal in condition" do
120
- "foo if /bar/".
127
+ it 'handles bare regex literal in condition' do
128
+ 'foo if /bar/'.
121
129
  must_be_parsed_as s(:if,
122
130
  s(:match, s(:lit, /bar/)),
123
131
  s(:call, nil, :foo),
124
132
  nil)
125
133
  end
126
134
 
127
- it "handles interpolated regex in condition" do
135
+ it 'handles interpolated regex in condition' do
128
136
  'foo if /#{bar}/'.
129
137
  must_be_parsed_as s(:if,
130
- s(:dregx, "", s(:evstr, s(:call, nil, :bar))),
138
+ s(:dregx, '', s(:evstr, s(:call, nil, :bar))),
131
139
  s(:call, nil, :foo),
132
140
  nil)
133
141
  end
142
+
143
+ it 'handles negative match operator' do
144
+ 'baz if foo !~ bar'.
145
+ must_be_parsed_as s(:if,
146
+ s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
147
+ nil,
148
+ s(:call, nil, :baz))
149
+ end
134
150
  end
135
151
 
136
- describe "for regular unless" do
137
- it "works with a single statement" do
138
- "unless bar; foo; end".
152
+ describe 'for regular unless' do
153
+ it 'works with a single statement' do
154
+ 'unless bar; foo; end'.
139
155
  must_be_parsed_as s(:if,
140
156
  s(:call, nil, :bar),
141
157
  nil,
142
158
  s(:call, nil, :foo))
143
159
  end
144
160
 
145
- it "works with an else clause" do
146
- "unless foo; bar; else; baz; end".
161
+ it 'works with an else clause' do
162
+ 'unless foo; bar; else; baz; end'.
147
163
  must_be_parsed_as s(:if,
148
164
  s(:call, nil, :foo),
149
165
  s(:call, nil, :baz),
150
166
  s(:call, nil, :bar))
151
167
  end
152
- it "handles bare regex literal in condition" do
153
- "unless /foo/; bar; end".
168
+ it 'handles bare regex literal in condition' do
169
+ 'unless /foo/; bar; end'.
154
170
  must_be_parsed_as s(:if,
155
171
  s(:match, s(:lit, /foo/)),
156
172
  nil,
157
173
  s(:call, nil, :bar))
158
174
  end
159
175
 
160
- it "handles interpolated regex in condition" do
176
+ it 'handles interpolated regex in condition' do
161
177
  'unless /#{foo}/; bar; end'.
162
178
  must_be_parsed_as s(:if,
163
- s(:dregx, "", s(:evstr, s(:call, nil, :foo))),
179
+ s(:dregx, '', s(:evstr, s(:call, nil, :foo))),
164
180
  nil,
165
181
  s(:call, nil, :bar))
166
182
  end
183
+
184
+ it 'handles negative match operator' do
185
+ 'unless foo !~ bar; baz; else; qux; end'.
186
+ must_be_parsed_as s(:if,
187
+ s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
188
+ s(:call, nil, :baz),
189
+ s(:call, nil, :qux))
190
+ end
167
191
  end
168
192
 
169
- describe "for postfix unless" do
170
- it "works with a simple condition" do
171
- "foo unless bar".
193
+ describe 'for postfix unless' do
194
+ it 'works with a simple condition' do
195
+ 'foo unless bar'.
172
196
  must_be_parsed_as s(:if,
173
197
  s(:call, nil, :bar),
174
198
  nil,
175
199
  s(:call, nil, :foo))
176
200
  end
177
201
 
178
- it "handles bare regex literal in condition" do
179
- "foo unless /bar/".
202
+ it 'handles bare regex literal in condition' do
203
+ 'foo unless /bar/'.
180
204
  must_be_parsed_as s(:if,
181
205
  s(:match, s(:lit, /bar/)),
182
206
  nil,
183
207
  s(:call, nil, :foo))
184
208
  end
185
209
 
186
- it "handles interpolated regex in condition" do
210
+ it 'handles interpolated regex in condition' do
187
211
  'foo unless /#{bar}/'.
188
212
  must_be_parsed_as s(:if,
189
- s(:dregx, "", s(:evstr, s(:call, nil, :bar))),
213
+ s(:dregx, '', s(:evstr, s(:call, nil, :bar))),
190
214
  nil,
191
215
  s(:call, nil, :foo))
192
216
  end
217
+
218
+ it 'handles negative match operator' do
219
+ 'baz unless foo !~ bar'.
220
+ must_be_parsed_as s(:if,
221
+ s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
222
+ s(:call, nil, :baz),
223
+ nil)
224
+ end
193
225
  end
194
226
 
195
- describe "for case block" do
196
- it "works with a single when clause" do
197
- "case foo; when bar; baz; end".
227
+ describe 'for case block' do
228
+ it 'works with a single when clause' do
229
+ 'case foo; when bar; baz; end'.
198
230
  must_be_parsed_as s(:case,
199
231
  s(:call, nil, :foo),
200
232
  s(:when,
@@ -203,8 +235,8 @@ describe RipperRubyParser::Parser do
203
235
  nil)
204
236
  end
205
237
 
206
- it "works with multiple when clauses" do
207
- "case foo; when bar; baz; when qux; quux; end".
238
+ it 'works with multiple when clauses' do
239
+ 'case foo; when bar; baz; when qux; quux; end'.
208
240
  must_be_parsed_as s(:case,
209
241
  s(:call, nil, :foo),
210
242
  s(:when,
@@ -216,8 +248,8 @@ describe RipperRubyParser::Parser do
216
248
  nil)
217
249
  end
218
250
 
219
- it "works with multiple statements in the when block" do
220
- "case foo; when bar; baz; qux; end".
251
+ it 'works with multiple statements in the when block' do
252
+ 'case foo; when bar; baz; qux; end'.
221
253
  must_be_parsed_as s(:case,
222
254
  s(:call, nil, :foo),
223
255
  s(:when,
@@ -227,8 +259,8 @@ describe RipperRubyParser::Parser do
227
259
  nil)
228
260
  end
229
261
 
230
- it "works with an else clause" do
231
- "case foo; when bar; baz; else; qux; end".
262
+ it 'works with an else clause' do
263
+ 'case foo; when bar; baz; else; qux; end'.
232
264
  must_be_parsed_as s(:case,
233
265
  s(:call, nil, :foo),
234
266
  s(:when,
@@ -237,16 +269,16 @@ describe RipperRubyParser::Parser do
237
269
  s(:call, nil, :qux))
238
270
  end
239
271
 
240
- it "works with an empty when block" do
241
- "case foo; when bar; end".
272
+ it 'works with an empty when block' do
273
+ 'case foo; when bar; end'.
242
274
  must_be_parsed_as s(:case,
243
275
  s(:call, nil, :foo),
244
276
  s(:when, s(:array, s(:call, nil, :bar)), nil),
245
277
  nil)
246
278
  end
247
279
 
248
- it "works with an empty else block" do
249
- "case foo; when bar; baz; else; end".
280
+ it 'works with an empty else block' do
281
+ 'case foo; when bar; baz; else; end'.
250
282
  must_be_parsed_as s(:case,
251
283
  s(:call, nil, :foo),
252
284
  s(:when,
@@ -255,8 +287,8 @@ describe RipperRubyParser::Parser do
255
287
  nil)
256
288
  end
257
289
 
258
- it "works with a splat in the when clause" do
259
- "case foo; when *bar; baz; end".
290
+ it 'works with a splat in the when clause' do
291
+ 'case foo; when *bar; baz; end'.
260
292
  must_be_parsed_as s(:case,
261
293
  s(:call, nil, :foo),
262
294
  s(:when,